Quickstart

npm install @visiq/harness ai @ai-sdk/openai "zod@^3"

import { visiq } from "@visiq/harness";
import { Experimental_Agent as Agent, stepCountIs, tool } from "ai";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";

// Stub knowledge base — swap in your real vector store. Returning
// { pageContent, metadata }[] documents lets retrieval governance
// evaluate each one.
const searchDocs = async (query: string) => [
  { pageContent: `Indexed result for "${query}"`, metadata: { classification: "internal" } },
];

// Your tools — unchanged.
const tools = {
  issue_refund: tool({
    description: "Issue a refund to a customer",
    inputSchema: z.object({ customerId: z.string(), amount: z.number() }),
    execute: async ({ customerId, amount }) => `Refunded $${amount} to ${customerId}`,
  }),
  search_knowledge: tool({
    description: "Search the company knowledge base",
    inputSchema: z.object({ query: z.string() }),
    execute: async ({ query }) => searchDocs(query),
  }),
};

// ── One call — wrap the agent: governance + per-run LLM telemetry activate here ──
const agent = visiq(
  new Agent({
    model: openai("gpt-4o"),
    instructions: "You are a helpful assistant.",
    tools,
    stopWhen: stepCountIs(8),
  }),
  { agentId: "support-bot" },
);

const result = await agent.generate({ prompt: "What was Q3 revenue?" });

npm install @visiq/harness @mastra/core "zod@^3"

import { visiq } from "@visiq/harness";
import { Agent } from "@mastra/core/agent";
import { createTool } from "@mastra/core/tools";
import { z } from "zod";

// Stub knowledge base — swap in your real vector store (e.g.
// createVectorQueryTool from @mastra/rag). Returning documents lets
// retrieval governance evaluate each one.
const searchDocs = async (query: string) => [
  { pageContent: `Indexed result for "${query}"`, metadata: { classification: "internal" } },
];

// Your tools — unchanged.
const tools = {
  issue_refund: createTool({
    id: "issue_refund",
    description: "Issue a refund to a customer",
    inputSchema: z.object({ customerId: z.string(), amount: z.number() }),
    execute: async ({ customerId, amount }) => `Refunded $${amount} to ${customerId}`,
  }),
  search_knowledge: createTool({
    id: "search_knowledge",
    description: "Search the company knowledge base",
    inputSchema: z.object({ query: z.string() }),
    execute: async ({ query }) => searchDocs(query),
  }),
};

// ── One call — wrap the agent: governance + per-run LLM telemetry activate here ──
const agent = visiq(
  new Agent({
    id: "support",
    name: "support",
    instructions: "You are a helpful assistant.",
    model: "openai/gpt-4o",
    tools,
  }),
  { agentId: "support-bot" },
);

const result = await agent.generate("What was Q3 revenue?");

npm install @visiq/harness @openai/agents zod

import { visiq } from "@visiq/harness";
import { Agent, run, tool } from "@openai/agents";
import { z } from "zod";

// Stub knowledge base — swap in your real vector store. Returning
// { pageContent, metadata }[] documents lets retrieval governance
// evaluate each one.
const searchDocs = async (query: string) => [
  { pageContent: `Indexed result for "${query}"`, metadata: { classification: "internal" } },
];

// Your tools — unchanged.
const tools = [
  tool({
    name: "issue_refund",
    description: "Issue a refund to a customer",
    parameters: z.object({ customerId: z.string(), amount: z.number() }),
    execute: async ({ customerId, amount }) => `Refunded $${amount} to ${customerId}`,
  }),
  tool({
    name: "search_knowledge",
    description: "Search the company knowledge base",
    parameters: z.object({ query: z.string() }),
    execute: async ({ query }) => searchDocs(query),
  }),
];

// ── One call — wrap the agent: governance + per-run telemetry activate here ──
const agent = visiq(
  new Agent({ name: "support", instructions: "You are a helpful assistant.", tools, model: "gpt-4o" }),
  { agentId: "support-bot" },
);

const result = await run(agent, "What was Q3 revenue?");
console.log(result.finalOutput);

npm install @visiq/harness llamaindex @llamaindex/workflow @llamaindex/openai "zod@^3"

import { visiq } from "@visiq/harness";
import { tool } from "llamaindex";
import { agent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";
import { z } from "zod";

// Stub knowledge base — swap in a real LlamaIndex retriever or vector
// store. Returning documents lets retrieval governance evaluate each one.
const searchDocs = async (query: string) => [
  { pageContent: `Indexed result for "${query}"`, metadata: { classification: "internal" } },
];

// Your tools — unchanged.
const tools = [
  tool({
    name: "issue_refund",
    description: "Issue a refund to a customer",
    parameters: z.object({ customerId: z.string(), amount: z.number() }),
    execute: async ({ customerId, amount }) => `Refunded $${amount} to ${customerId}`,
  }),
  tool({
    name: "search_knowledge",
    description: "Search the company knowledge base",
    parameters: z.object({ query: z.string() }),
    execute: async ({ query }) => searchDocs(query),
  }),
];

// ── One call — wrap the agent workflow: governance + per-run session activate here ──
const supportAgent = visiq(
  agent({ name: "support", llm: openai({ model: "gpt-4o" }), tools, systemPrompt: "You are a helpful assistant." }),
  { agentId: "support-bot" },
);

const result = await supportAgent.run("What was Q3 revenue?");
console.log(result.data.result);

npm install @visiq/harness @voltagent/core @voltagent/logger @ai-sdk/openai ai "zod@^3"

import { visiq } from "@visiq/harness";
import { Agent, createTool } from "@voltagent/core";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";

// Stub knowledge base — swap in your real vector store. Returning
// { pageContent, metadata }[] documents lets retrieval governance
// evaluate each one.
const searchDocs = async (query: string) => [
  { pageContent: `Indexed result for "${query}"`, metadata: { classification: "internal" } },
];

// Your tools — unchanged.
const tools = [
  createTool({
    name: "issue_refund",
    description: "Issue a refund to a customer",
    parameters: z.object({ customerId: z.string(), amount: z.number() }),
    execute: async ({ customerId, amount }) => `Refunded $${amount} to ${customerId}`,
  }),
  createTool({
    name: "search_knowledge",
    description: "Search the company knowledge base",
    parameters: z.object({ query: z.string() }),
    execute: async ({ query }) => searchDocs(query),
  }),
];

// ── One call — wrap the agent: governance + per-run LLM telemetry activate here ──
const agent = visiq(
  new Agent({ name: "support", instructions: "You are a helpful assistant.", model: openai("gpt-4o"), tools }),
  { agentId: "support-bot" },
);

const result = await agent.generateText("What was Q3 revenue?");
console.log(result.text);

npm install @visiq/harness semantic-kernel   # community JavaScript port
pip install visiq semantic-kernel            # Microsoft's official Python SDK

import { visiq } from "@visiq/harness";
// Build your Semantic Kernel `kernel` as usual (AI service + plugins/functions).

// ── One call — governance + audit trail activate on every KernelFunction ──
const governedKernel = visiq(kernel, { agentId: "support-bot" });

// Invoke functions exactly as before — every call is now governed.