@lssm/lib.ai-agent 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217073102

package/dist/agent/agent-factory.js

@@ -1 +1,102 @@
-import{ContractSpecAgent as e}from"./contract-spec-agent.js";var t=class{config;cache=new Map;constructor(e){this.config=e}async create(e,t,n){let r=this.config.registry.require(e,t);return this.createFromSpec(r,n)}async createFromSpec(t,n){let r=new Map(this.config.toolHandlers);if(n?.toolHandlers)for(let[e,t]of n.toolHandlers)r.set(e,t);let i={...this.config.additionalTools,...n?.additionalTools};return e.create({spec:t,model:n?.model??this.config.defaultModel,toolHandlers:r,knowledgeRetriever:this.config.knowledgeRetriever,sessionStore:this.config.sessionStore,telemetryCollector:this.config.telemetryCollector,additionalTools:i})}async getOrCreate(e,t){let n=this.config.registry.require(e,t),r=`${n.meta.name}.v${n.meta.version}`,i=this.cache.get(r);return i||(i=await this.createFromSpec(n),this.cache.set(r,i)),i}clearCache(){this.cache.clear()}listAvailable(){return this.config.registry.listNames()}};function n(e){return new t(e)}export{t as AgentFactory,n as createAgentFactory};
+import { ContractSpecAgent } from "./contract-spec-agent.js";
+
+//#region src/agent/agent-factory.ts
+/**
+* Factory for creating ContractSpec agents from specs.
+*
+* Provides a centralized way to instantiate agents with
+* consistent configuration.
+*
+* @example
+* ```typescript
+* const factory = createAgentFactory({
+*   defaultModel: mistral('mistral-large-latest'),
+*   registry: agentRegistry,
+*   toolHandlers: globalToolHandlers,
+*   sessionStore: mySessionStore,
+* });
+*
+* const agent = await factory.create('support.bot');
+* const result = await agent.generate({ prompt: 'Help me with...' });
+* ```
+*/
+var AgentFactory = class {
+	config;
+	cache = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Create an agent by name.
+	*
+	* @param name - Agent name (e.g., "support.bot")
+	* @param version - Optional specific version
+	* @param options - Optional creation options
+	*/
+	async create(name, version, options) {
+		const spec = this.config.registry.require(name, version);
+		return this.createFromSpec(spec, options);
+	}
+	/**
+	* Create an agent from a spec directly.
+	*
+	* @param spec - Agent specification
+	* @param options - Optional creation options
+	*/
+	async createFromSpec(spec, options) {
+		const mergedHandlers = new Map(this.config.toolHandlers);
+		if (options?.toolHandlers) for (const [key, handler] of options.toolHandlers) mergedHandlers.set(key, handler);
+		const mergedTools = {
+			...this.config.additionalTools,
+			...options?.additionalTools
+		};
+		return ContractSpecAgent.create({
+			spec,
+			model: options?.model ?? this.config.defaultModel,
+			toolHandlers: mergedHandlers,
+			knowledgeRetriever: this.config.knowledgeRetriever,
+			sessionStore: this.config.sessionStore,
+			telemetryCollector: this.config.telemetryCollector,
+			additionalTools: mergedTools
+		});
+	}
+	/**
+	* Get or create a cached agent instance.
+	*
+	* Use this when you want to reuse agent instances.
+	*
+	* @param name - Agent name
+	* @param version - Optional specific version
+	*/
+	async getOrCreate(name, version) {
+		const spec = this.config.registry.require(name, version);
+		const cacheKey = `${spec.meta.name}.v${spec.meta.version}`;
+		let agent = this.cache.get(cacheKey);
+		if (!agent) {
+			agent = await this.createFromSpec(spec);
+			this.cache.set(cacheKey, agent);
+		}
+		return agent;
+	}
+	/**
+	* Clear the agent cache.
+	*/
+	clearCache() {
+		this.cache.clear();
+	}
+	/**
+	* List all available agent names.
+	*/
+	listAvailable() {
+		return this.config.registry.listNames();
+	}
+};
+/**
+* Create an agent factory.
+*/
+function createAgentFactory(config) {
+	return new AgentFactory(config);
+}
+
+//#endregion
+export { AgentFactory, createAgentFactory };

package/dist/agent/contract-spec-agent.js

@@ -1 +1,147 @@
-import{agentKey as e}from"../spec/spec.js";import{specToolsToAISDKTools as t}from"../tools/tool-adapter.js";import{createKnowledgeQueryTool as n}from"../tools/knowledge-tool.js";import{injectStaticKnowledge as r}from"../knowledge/injector.js";import{generateSessionId as i}from"../session/store.js";import{trackAgentStep as a}from"../telemetry/adapter.js";import{Experimental_Agent as o,stepCountIs as s}from"ai";import*as c from"zod";const l=c.object({tenantId:c.string().optional(),actorId:c.string().optional(),sessionId:c.string().optional(),metadata:c.record(c.string(),c.unknown()).optional()});var u=class c{version=`agent-v1`;id;spec;tools;inner;config;instructions;constructor(t,n,r){this.config=t,this.spec=t.spec,this.id=e(t.spec.meta),this.tools=r,this.instructions=n,this.inner=new o({model:t.model,instructions:n,tools:r,stopWhen:s(t.spec.maxSteps??10),callOptionsSchema:l,onStepFinish:async e=>{await this.handleStepFinish(e)}})}static async create(i){let a=await r(i.spec.instructions,i.spec.knowledge??[],i.knowledgeRetriever),o=t(i.spec.tools,i.toolHandlers,{agentId:e(i.spec.meta)}),s=i.knowledgeRetriever?n(i.knowledgeRetriever,i.spec.knowledge??[]):null;return new c(i,a,{...o,...s?{query_knowledge:s}:{},...i.additionalTools??{}})}async generate(e){let t=e.options?.sessionId??i();this.config.sessionStore&&(await this.config.sessionStore.get(t)||await this.config.sessionStore.create({sessionId:t,agentId:this.id,tenantId:e.options?.tenantId,actorId:e.options?.actorId,status:`running`,messages:[],steps:[],metadata:e.options?.metadata}));let n=e.systemOverride?`${this.instructions}\n\n${e.systemOverride}\n\n${e.prompt}`:e.prompt,r=await this.inner.generate({prompt:n,abortSignal:e.signal,options:{tenantId:e.options?.tenantId,actorId:e.options?.actorId,sessionId:t,metadata:e.options?.metadata}});return this.config.sessionStore&&await this.config.sessionStore.update(t,{status:`completed`}),{text:r.text,steps:r.steps,toolCalls:r.toolCalls.map(e=>({type:`tool-call`,toolCallId:e.toolCallId,toolName:e.toolName,args:`args`in e?e.args:`input`in e?e.input:void 0})),toolResults:r.toolResults.map(e=>({type:`tool-result`,toolCallId:e.toolCallId,toolName:e.toolName,output:e.output})),finishReason:r.finishReason,usage:r.usage}}async stream(e){let t=e.options?.sessionId??i(),n=e.systemOverride?`${this.instructions}\n\n${e.systemOverride}\n\n${e.prompt}`:e.prompt;return this.inner.stream({prompt:n,abortSignal:e.signal,options:{tenantId:e.options?.tenantId,actorId:e.options?.actorId,sessionId:t,metadata:e.options?.metadata}})}async handleStepFinish(e){let t=e.options?.sessionId;t&&this.config.sessionStore&&await this.config.sessionStore.appendStep(t,e),this.config.telemetryCollector&&await a(this.config.telemetryCollector,this.id,e)}};export{u as ContractSpecAgent};
+import { agentKey } from "../spec/spec.js";
+import { specToolsToAISDKTools } from "../tools/tool-adapter.js";
+import { createKnowledgeQueryTool } from "../tools/knowledge-tool.js";
+import { injectStaticKnowledge } from "../knowledge/injector.js";
+import { generateSessionId } from "../session/store.js";
+import { trackAgentStep } from "../telemetry/adapter.js";
+import { Experimental_Agent, stepCountIs } from "ai";
+import * as z$1 from "zod";
+
+//#region src/agent/contract-spec-agent.ts
+/**
+* Call options schema for AI SDK v6.
+* Maps ContractSpec's tenant/actor system to AI SDK callOptionsSchema.
+*/
+const ContractSpecCallOptionsSchema = z$1.object({
+	tenantId: z$1.string().optional(),
+	actorId: z$1.string().optional(),
+	sessionId: z$1.string().optional(),
+	metadata: z$1.record(z$1.string(), z$1.unknown()).optional()
+});
+/**
+* ContractSpec Agent implementation using AI SDK v6.
+*
+* Integrates ContractSpec's spec-first governance with AI SDK's
+* ToolLoopAgent, providing:
+* - Spec-defined tools with type-safe handlers
+* - Hybrid knowledge injection (static + dynamic RAG)
+* - Session persistence
+* - Telemetry for evolution
+* - MCP interoperability
+*/
+var ContractSpecAgent = class ContractSpecAgent {
+	version = "agent-v1";
+	id;
+	spec;
+	tools;
+	inner;
+	config;
+	instructions;
+	constructor(config, instructions, tools) {
+		this.config = config;
+		this.spec = config.spec;
+		this.id = agentKey(config.spec.meta);
+		this.tools = tools;
+		this.instructions = instructions;
+		this.inner = new Experimental_Agent({
+			model: config.model,
+			instructions,
+			tools,
+			stopWhen: stepCountIs(config.spec.maxSteps ?? 10),
+			callOptionsSchema: ContractSpecCallOptionsSchema,
+			onStepFinish: async (step) => {
+				await this.handleStepFinish(step);
+			}
+		});
+	}
+	/**
+	* Create a ContractSpecAgent instance.
+	* This is async because knowledge injection may need to fetch static content.
+	*/
+	static async create(config) {
+		const instructions = await injectStaticKnowledge(config.spec.instructions, config.spec.knowledge ?? [], config.knowledgeRetriever);
+		const specTools = specToolsToAISDKTools(config.spec.tools, config.toolHandlers, { agentId: agentKey(config.spec.meta) });
+		const knowledgeTool = config.knowledgeRetriever ? createKnowledgeQueryTool(config.knowledgeRetriever, config.spec.knowledge ?? []) : null;
+		return new ContractSpecAgent(config, instructions, {
+			...specTools,
+			...knowledgeTool ? { query_knowledge: knowledgeTool } : {},
+			...config.additionalTools ?? {}
+		});
+	}
+	/**
+	* Generate a response (non-streaming).
+	*/
+	async generate(params) {
+		const sessionId = params.options?.sessionId ?? generateSessionId();
+		if (this.config.sessionStore) {
+			if (!await this.config.sessionStore.get(sessionId)) await this.config.sessionStore.create({
+				sessionId,
+				agentId: this.id,
+				tenantId: params.options?.tenantId,
+				actorId: params.options?.actorId,
+				status: "running",
+				messages: [],
+				steps: [],
+				metadata: params.options?.metadata
+			});
+		}
+		const prompt = params.systemOverride ? `${this.instructions}\n\n${params.systemOverride}\n\n${params.prompt}` : params.prompt;
+		const result = await this.inner.generate({
+			prompt,
+			abortSignal: params.signal,
+			options: {
+				tenantId: params.options?.tenantId,
+				actorId: params.options?.actorId,
+				sessionId,
+				metadata: params.options?.metadata
+			}
+		});
+		if (this.config.sessionStore) await this.config.sessionStore.update(sessionId, { status: "completed" });
+		return {
+			text: result.text,
+			steps: result.steps,
+			toolCalls: result.toolCalls.map((tc) => ({
+				type: "tool-call",
+				toolCallId: tc.toolCallId,
+				toolName: tc.toolName,
+				args: "args" in tc ? tc.args : "input" in tc ? tc.input : void 0
+			})),
+			toolResults: result.toolResults.map((tr) => ({
+				type: "tool-result",
+				toolCallId: tr.toolCallId,
+				toolName: tr.toolName,
+				output: tr.output
+			})),
+			finishReason: result.finishReason,
+			usage: result.usage
+		};
+	}
+	/**
+	* Stream a response with real-time updates.
+	*/
+	async stream(params) {
+		const sessionId = params.options?.sessionId ?? generateSessionId();
+		const prompt = params.systemOverride ? `${this.instructions}\n\n${params.systemOverride}\n\n${params.prompt}` : params.prompt;
+		return this.inner.stream({
+			prompt,
+			abortSignal: params.signal,
+			options: {
+				tenantId: params.options?.tenantId,
+				actorId: params.options?.actorId,
+				sessionId,
+				metadata: params.options?.metadata
+			}
+		});
+	}
+	/**
+	* Handle step completion for persistence and telemetry.
+	*/
+	async handleStepFinish(step) {
+		const sessionId = step.options?.sessionId;
+		if (sessionId && this.config.sessionStore) await this.config.sessionStore.appendStep(sessionId, step);
+		if (this.config.telemetryCollector) await trackAgentStep(this.config.telemetryCollector, this.id, step);
+	}
+};
+
+//#endregion
+export { ContractSpecAgent };

package/dist/agent/index.js

@@ -1 +1,4 @@
-import{ContractSpecAgent as e}from"./contract-spec-agent.js";import{AgentFactory as t,createAgentFactory as n}from"./agent-factory.js";export{t as AgentFactory,e as ContractSpecAgent,n as createAgentFactory};
+import { ContractSpecAgent } from "./contract-spec-agent.js";
+import { AgentFactory, createAgentFactory } from "./agent-factory.js";
+
+export { AgentFactory, ContractSpecAgent, createAgentFactory };

package/dist/approval/index.js

@@ -1 +1,3 @@
-import{ApprovalWorkflow as e,InMemoryApprovalStore as t,createApprovalWorkflow as n}from"./workflow.js";export{e as ApprovalWorkflow,t as InMemoryApprovalStore,n as createApprovalWorkflow};
+import { ApprovalWorkflow, InMemoryApprovalStore, createApprovalWorkflow } from "./workflow.js";
+
+export { ApprovalWorkflow, InMemoryApprovalStore, createApprovalWorkflow };

package/dist/approval/workflow.js

@@ -1 +1,159 @@
-import{randomUUID as e}from"node:crypto";var t=class{items=new Map;async create(e){this.items.set(e.id,e)}async get(e){return this.items.get(e)??null}async getByToolCallId(e){for(let t of this.items.values())if(t.toolCallId===e)return t;return null}async update(e,t){let n=this.items.get(e);n&&this.items.set(e,{...n,...t})}async list(e){let t=[...this.items.values()];return e?.status&&(t=t.filter(t=>t.status===e.status)),e?.agentId&&(t=t.filter(t=>t.agentId===e.agentId)),e?.tenantId&&(t=t.filter(t=>t.tenantId===e.tenantId)),t.sort((e,t)=>t.requestedAt.getTime()-e.requestedAt.getTime())}clear(){this.items.clear()}},n=class{constructor(e=new t){this.store=e}async requestApproval(t){let n={id:e(),sessionId:t.sessionId,agentId:t.agentId,tenantId:t.tenantId,toolName:t.toolName,toolCallId:t.toolCallId,toolArgs:t.toolArgs,reason:t.reason,requestedAt:new Date,status:`pending`,payload:t.payload};return await this.store.create(n),n}async requestApprovalFromToolCall(e,t){return this.requestApproval({sessionId:t.sessionId,agentId:t.agentId,tenantId:t.tenantId,toolName:e.toolName,toolCallId:e.toolCallId,toolArgs:e.args,reason:t.reason??`Tool "${e.toolName}" requires approval`})}async approve(e,t,n){await this.store.update(e,{status:`approved`,reviewer:t,resolvedAt:new Date,notes:n})}async reject(e,t,n){await this.store.update(e,{status:`rejected`,reviewer:t,resolvedAt:new Date,notes:n})}async getStatus(e){return(await this.store.getByToolCallId(e))?.status??null}async isApproved(e){return await this.getStatus(e)===`approved`}async listPending(e){return this.store.list({...e,status:`pending`})}async get(e){return this.store.get(e)}};function r(e){return new n(e)}export{n as ApprovalWorkflow,t as InMemoryApprovalStore,r as createApprovalWorkflow};
+import { randomUUID } from "node:crypto";
+
+//#region src/approval/workflow.ts
+/**
+* In-memory approval store for development and testing.
+*/
+var InMemoryApprovalStore = class {
+	items = /* @__PURE__ */ new Map();
+	async create(request) {
+		this.items.set(request.id, request);
+	}
+	async get(id) {
+		return this.items.get(id) ?? null;
+	}
+	async getByToolCallId(toolCallId) {
+		for (const request of this.items.values()) if (request.toolCallId === toolCallId) return request;
+		return null;
+	}
+	async update(id, updates) {
+		const existing = this.items.get(id);
+		if (existing) this.items.set(id, {
+			...existing,
+			...updates
+		});
+	}
+	async list(options) {
+		let results = [...this.items.values()];
+		if (options?.status) results = results.filter((r) => r.status === options.status);
+		if (options?.agentId) results = results.filter((r) => r.agentId === options.agentId);
+		if (options?.tenantId) results = results.filter((r) => r.tenantId === options.tenantId);
+		return results.sort((a, b) => b.requestedAt.getTime() - a.requestedAt.getTime());
+	}
+	clear() {
+		this.items.clear();
+	}
+};
+/**
+* Approval workflow for managing tool execution approvals.
+*
+* Integrates with AI SDK v6's `needsApproval` feature on tools.
+*
+* @example
+* ```typescript
+* const workflow = new ApprovalWorkflow();
+*
+* // When a tool needs approval
+* const request = await workflow.requestApproval({
+*   sessionId: 'sess_123',
+*   agentId: 'support.bot.v1',
+*   toolName: 'delete_account',
+*   toolCallId: 'call_abc',
+*   toolArgs: { userId: 'user_123' },
+*   reason: 'Account deletion requires human approval',
+* });
+*
+* // When approval is granted
+* await workflow.approve(request.id, 'admin@example.com', 'Verified identity');
+*
+* // Or rejected
+* await workflow.reject(request.id, 'admin@example.com', 'Suspicious activity');
+* ```
+*/
+var ApprovalWorkflow = class {
+	constructor(store = new InMemoryApprovalStore()) {
+		this.store = store;
+	}
+	/**
+	* Request approval for a tool execution.
+	*/
+	async requestApproval(params) {
+		const request = {
+			id: randomUUID(),
+			sessionId: params.sessionId,
+			agentId: params.agentId,
+			tenantId: params.tenantId,
+			toolName: params.toolName,
+			toolCallId: params.toolCallId,
+			toolArgs: params.toolArgs,
+			reason: params.reason,
+			requestedAt: /* @__PURE__ */ new Date(),
+			status: "pending",
+			payload: params.payload
+		};
+		await this.store.create(request);
+		return request;
+	}
+	/**
+	* Request approval from an AI SDK tool call.
+	*/
+	async requestApprovalFromToolCall(toolCall, context) {
+		return this.requestApproval({
+			sessionId: context.sessionId,
+			agentId: context.agentId,
+			tenantId: context.tenantId,
+			toolName: toolCall.toolName,
+			toolCallId: toolCall.toolCallId,
+			toolArgs: toolCall.args,
+			reason: context.reason ?? `Tool "${toolCall.toolName}" requires approval`
+		});
+	}
+	/**
+	* Approve a pending request.
+	*/
+	async approve(id, reviewer, notes) {
+		await this.store.update(id, {
+			status: "approved",
+			reviewer,
+			resolvedAt: /* @__PURE__ */ new Date(),
+			notes
+		});
+	}
+	/**
+	* Reject a pending request.
+	*/
+	async reject(id, reviewer, notes) {
+		await this.store.update(id, {
+			status: "rejected",
+			reviewer,
+			resolvedAt: /* @__PURE__ */ new Date(),
+			notes
+		});
+	}
+	/**
+	* Get approval status for a tool call.
+	*/
+	async getStatus(toolCallId) {
+		return (await this.store.getByToolCallId(toolCallId))?.status ?? null;
+	}
+	/**
+	* Check if a tool call is approved.
+	*/
+	async isApproved(toolCallId) {
+		return await this.getStatus(toolCallId) === "approved";
+	}
+	/**
+	* List pending approvals.
+	*/
+	async listPending(options) {
+		return this.store.list({
+			...options,
+			status: "pending"
+		});
+	}
+	/**
+	* Get approval request by ID.
+	*/
+	async get(id) {
+		return this.store.get(id);
+	}
+};
+/**
+* Create an approval workflow instance.
+*/
+function createApprovalWorkflow(store) {
+	return new ApprovalWorkflow(store);
+}
+
+//#endregion
+export { ApprovalWorkflow, InMemoryApprovalStore, createApprovalWorkflow };

package/dist/index.js

@@ -1 +1,21 @@
-import{agentKey as e,defineAgent as t}from"./spec/spec.js";import{jsonSchemaToZod as n,jsonSchemaToZodSafe as r}from"./schema/json-schema-to-zod.js";import{buildToolHandlers as i,createToolHandler as a,specToolToAISDKTool as o,specToolsToAISDKTools as s}from"./tools/tool-adapter.js";import{createKnowledgeQueryTool as c}from"./tools/knowledge-tool.js";import{createKnowledgeInjector as l,injectStaticKnowledge as u}from"./knowledge/injector.js";import{InMemorySessionStore as d,createInMemorySessionStore as f,generateSessionId as p}from"./session/store.js";import{InMemoryTelemetryCollector as m,createInMemoryTelemetryCollector as h,noopTelemetryCollector as g,trackAgentStep as _}from"./telemetry/adapter.js";import{ContractSpecAgent as v}from"./agent/contract-spec-agent.js";import{AgentFactory as y,createAgentFactory as b}from"./agent/agent-factory.js";import"./agent/index.js";import{AgentRegistry as x,createAgentRegistry as S}from"./spec/registry.js";import{createMcpToolsets as C,mcpServerToTools as w}from"./tools/mcp-client.js";import{agentToMcpServer as T,createAgentMcpServer as E}from"./tools/mcp-server.js";import"./tools/index.js";import{SchemaOutput as D,enumToChoiceOutput as O,jsonSchemaToArrayOutput as k,jsonSchemaToOutput as A,textOutput as j,zodToOutput as M}from"./schema/schema-output.js";import"./schema/index.js";import{ApprovalWorkflow as N,InMemoryApprovalStore as P,createApprovalWorkflow as F}from"./approval/workflow.js";import"./approval/index.js";import{Experimental_Agent as I}from"ai";export{y as AgentFactory,x as AgentRegistry,N as ApprovalWorkflow,v as ContractSpecAgent,P as InMemoryApprovalStore,d as InMemorySessionStore,m as InMemoryTelemetryCollector,D as SchemaOutput,I as ToolLoopAgent,e as agentKey,T as agentToMcpServer,i as buildToolHandlers,b as createAgentFactory,E as createAgentMcpServer,S as createAgentRegistry,F as createApprovalWorkflow,f as createInMemorySessionStore,h as createInMemoryTelemetryCollector,l as createKnowledgeInjector,c as createKnowledgeQueryTool,C as createMcpToolsets,a as createToolHandler,t as defineAgent,O as enumToChoiceOutput,p as generateSessionId,u as injectStaticKnowledge,k as jsonSchemaToArrayOutput,A as jsonSchemaToOutput,n as jsonSchemaToZod,r as jsonSchemaToZodSafe,w as mcpServerToTools,g as noopTelemetryCollector,o as specToolToAISDKTool,s as specToolsToAISDKTools,j as textOutput,_ as trackAgentStep,M as zodToOutput};
+import { agentKey, defineAgent } from "./spec/spec.js";
+import { jsonSchemaToZod, jsonSchemaToZodSafe } from "./schema/json-schema-to-zod.js";
+import { buildToolHandlers, createToolHandler, specToolToAISDKTool, specToolsToAISDKTools } from "./tools/tool-adapter.js";
+import { createKnowledgeQueryTool } from "./tools/knowledge-tool.js";
+import { createKnowledgeInjector, injectStaticKnowledge } from "./knowledge/injector.js";
+import { InMemorySessionStore, createInMemorySessionStore, generateSessionId } from "./session/store.js";
+import { InMemoryTelemetryCollector, createInMemoryTelemetryCollector, noopTelemetryCollector, trackAgentStep } from "./telemetry/adapter.js";
+import { ContractSpecAgent } from "./agent/contract-spec-agent.js";
+import { AgentFactory, createAgentFactory } from "./agent/agent-factory.js";
+import "./agent/index.js";
+import { AgentRegistry, createAgentRegistry } from "./spec/registry.js";
+import { createMcpToolsets, mcpServerToTools } from "./tools/mcp-client.js";
+import { agentToMcpServer, createAgentMcpServer } from "./tools/mcp-server.js";
+import "./tools/index.js";
+import { SchemaOutput, enumToChoiceOutput, jsonSchemaToArrayOutput, jsonSchemaToOutput, textOutput, zodToOutput } from "./schema/schema-output.js";
+import "./schema/index.js";
+import { ApprovalWorkflow, InMemoryApprovalStore, createApprovalWorkflow } from "./approval/workflow.js";
+import "./approval/index.js";
+import { Experimental_Agent as ToolLoopAgent } from "ai";
+
+export { AgentFactory, AgentRegistry, ApprovalWorkflow, ContractSpecAgent, InMemoryApprovalStore, InMemorySessionStore, InMemoryTelemetryCollector, SchemaOutput, ToolLoopAgent, agentKey, agentToMcpServer, buildToolHandlers, createAgentFactory, createAgentMcpServer, createAgentRegistry, createApprovalWorkflow, createInMemorySessionStore, createInMemoryTelemetryCollector, createKnowledgeInjector, createKnowledgeQueryTool, createMcpToolsets, createToolHandler, defineAgent, enumToChoiceOutput, generateSessionId, injectStaticKnowledge, jsonSchemaToArrayOutput, jsonSchemaToOutput, jsonSchemaToZod, jsonSchemaToZodSafe, mcpServerToTools, noopTelemetryCollector, specToolToAISDKTool, specToolsToAISDKTools, textOutput, trackAgentStep, zodToOutput };

package/dist/knowledge/index.js

@@ -1 +1,3 @@
-import{createKnowledgeInjector as e,injectStaticKnowledge as t}from"./injector.js";export{e as createKnowledgeInjector,t as injectStaticKnowledge};
+import { createKnowledgeInjector, injectStaticKnowledge } from "./injector.js";
+
+export { createKnowledgeInjector, injectStaticKnowledge };

package/dist/knowledge/injector.js

@@ -1,4 +1,38 @@
-async function e(e,t,n){if(!n)return e;let r=t.filter(e=>e.required);if(r.length===0)return e;let i=[];for(let e of r){if(!n.supportsSpace(e.key)){console.warn(`Required knowledge space "${e.key}" is not available`);continue}try{let t=await n.getStatic(e.key);if(t){let n=e.instructions?`## ${e.key}\n${e.instructions}`:`## ${e.key}`;i.push(`${n}\n\n${t}`)}}catch(t){console.warn(`Failed to load required knowledge "${e.key}":`,t)}}return i.length===0?e:`${e}
+//#region src/knowledge/injector.ts
+/**
+* Inject static knowledge into agent instructions.
+*
+* This function handles the "required" knowledge that should be
+* injected into the system prompt at agent initialization time.
+* Optional knowledge is handled by the knowledge query tool.
+*
+* @param instructions - Base agent instructions
+* @param knowledgeRefs - Knowledge references from the agent spec
+* @param retriever - Optional knowledge retriever
+* @returns Instructions with injected knowledge
+*/
+async function injectStaticKnowledge(instructions, knowledgeRefs, retriever) {
+	if (!retriever) return instructions;
+	const requiredRefs = knowledgeRefs.filter((ref) => ref.required);
+	if (requiredRefs.length === 0) return instructions;
+	const blocks = [];
+	for (const ref of requiredRefs) {
+		if (!retriever.supportsSpace(ref.key)) {
+			console.warn(`Required knowledge space "${ref.key}" is not available`);
+			continue;
+		}
+		try {
+			const content = await retriever.getStatic(ref.key);
+			if (content) {
+				const header = ref.instructions ? `## ${ref.key}\n${ref.instructions}` : `## ${ref.key}`;
+				blocks.push(`${header}\n\n${content}`);
+			}
+		} catch (error) {
+			console.warn(`Failed to load required knowledge "${ref.key}":`, error);
+		}
+	}
+	if (blocks.length === 0) return instructions;
+	return `${instructions}
 
 ---
 
@@ -6,8 +40,18 @@ async function e(e,t,n){if(!n)return e;let r=t.filter(e=>e.required);if(r.length
 
 The following information is provided for your reference. Use it to inform your responses.
 
-${i.join(`
+${blocks.join("\n\n---\n\n")}`;
+}
+/**
+* Create a knowledge injector instance for reuse.
+*/
+function createKnowledgeInjector(retriever) {
+	return {
+		inject: (instructions, knowledgeRefs) => injectStaticKnowledge(instructions, knowledgeRefs, retriever),
+		hasSpace: (spaceKey) => retriever?.supportsSpace(spaceKey) ?? false,
+		listSpaces: () => retriever?.listSpaces() ?? []
+	};
+}
 
----
-
-`)}`}function t(t){return{inject:(n,r)=>e(n,r,t),hasSpace:e=>t?.supportsSpace(e)??!1,listSpaces:()=>t?.listSpaces()??[]}}export{t as createKnowledgeInjector,e as injectStaticKnowledge};
+//#endregion
+export { createKnowledgeInjector, injectStaticKnowledge };

package/dist/memory/in-memory.js

@@ -1,2 +1,47 @@
-import{BaseAgentMemoryManager as e}from"./manager.js";var t=class extends e{ttlMs;maxEntries;store=new Map;constructor(e){super(),this.ttlMs=(e?.ttlMinutes??60)*60*1e3,this.maxEntries=e?.maxEntries??250}async load(e){this.evictExpired();let t=this.store.get(e);return t?(t.data.session.updatedAt=new Date,t.expiresAt=Date.now()+this.ttlMs,t.data):null}async save(e){this.trim(e.memory.entries),this.store.set(e.session.sessionId,{data:e,expiresAt:Date.now()+this.ttlMs})}async summarize(e){let t=await this.load(e.sessionId)??this.bootstrapMemory(e),n=t.memory.entries.slice(-10).map(e=>`- ${e.type}: ${e.content}`).join(`
-`);return t.memory.summary=n,t.memory.lastSummarizedAt=new Date,await this.save(t),t.memory}trim(e){e.length<=this.maxEntries||e.splice(0,e.length-this.maxEntries)}evictExpired(){let e=Date.now();for(let[t,n]of this.store.entries())n.expiresAt<=e&&this.store.delete(t)}};export{t as InMemoryAgentMemory};
+import { BaseAgentMemoryManager } from "./manager.js";
+
+//#region src/memory/in-memory.ts
+var InMemoryAgentMemory = class extends BaseAgentMemoryManager {
+	ttlMs;
+	maxEntries;
+	store = /* @__PURE__ */ new Map();
+	constructor(options) {
+		super();
+		this.ttlMs = (options?.ttlMinutes ?? 60) * 60 * 1e3;
+		this.maxEntries = options?.maxEntries ?? 250;
+	}
+	async load(sessionId) {
+		this.evictExpired();
+		const stored = this.store.get(sessionId);
+		if (!stored) return null;
+		stored.data.session.updatedAt = /* @__PURE__ */ new Date();
+		stored.expiresAt = Date.now() + this.ttlMs;
+		return stored.data;
+	}
+	async save(snapshot) {
+		this.trim(snapshot.memory.entries);
+		this.store.set(snapshot.session.sessionId, {
+			data: snapshot,
+			expiresAt: Date.now() + this.ttlMs
+		});
+	}
+	async summarize(session) {
+		const current = await this.load(session.sessionId) ?? this.bootstrapMemory(session);
+		const content = current.memory.entries.slice(-10).map((entry) => `- ${entry.type}: ${entry.content}`).join("\n");
+		current.memory.summary = content;
+		current.memory.lastSummarizedAt = /* @__PURE__ */ new Date();
+		await this.save(current);
+		return current.memory;
+	}
+	trim(entries) {
+		if (entries.length <= this.maxEntries) return;
+		entries.splice(0, entries.length - this.maxEntries);
+	}
+	evictExpired() {
+		const now = Date.now();
+		for (const [sessionId, stored] of this.store.entries()) if (stored.expiresAt <= now) this.store.delete(sessionId);
+	}
+};
+
+//#endregion
+export { InMemoryAgentMemory };

package/dist/memory/index.js

@@ -1 +1,4 @@
-import{BaseAgentMemoryManager as e,trackMessageInMemory as t}from"./manager.js";import{InMemoryAgentMemory as n}from"./in-memory.js";export{e as BaseAgentMemoryManager,n as InMemoryAgentMemory,t as trackMessageInMemory};
+import { BaseAgentMemoryManager, trackMessageInMemory } from "./manager.js";
+import { InMemoryAgentMemory } from "./in-memory.js";
+
+export { BaseAgentMemoryManager, InMemoryAgentMemory, trackMessageInMemory };

package/dist/memory/manager.js

@@ -1 +1,79 @@
-import{randomUUID as e}from"node:crypto";function t(e){let t=e.content;return typeof t==`string`?t:Array.isArray(t)?t.map(e=>typeof e==`string`?e:`text`in e&&typeof e.text==`string`?e.text:``).filter(Boolean).join(``):``}function n(e){let t=e.content;return typeof t==`string`?t:Array.isArray(t)?t.map(e=>typeof e==`string`?e:`text`in e&&typeof e.text==`string`?e.text:``).filter(Boolean).join(``):``}function r(e){switch(e){case`assistant`:return`assistant`;case`system`:return`system`;case`tool`:return`tool`;case`user`:default:return`user`}}var i=class{async append(t,n){let r=await this.load(t.sessionId)??this.bootstrapMemory(t),i={id:e(),createdAt:n.createdAt??new Date,...n};return r.memory.entries.push(i),await this.save(r),r}async summarize(e){}async prune(e){}bootstrapMemory(n){return{session:n,memory:{entries:n.messages.map(n=>({id:e(),createdAt:new Date,type:r(n.role),content:t(n)}))}}}};function a(e,t,r){e&&e.append(t,{type:r.role,content:n(r),metadata:r.metadata})}export{i as BaseAgentMemoryManager,a as trackMessageInMemory};
+import { randomUUID } from "node:crypto";
+
+//#region src/memory/manager.ts
+/**
+* Extract text content from a ModelMessage.
+* Handles both string content and array content parts.
+*/
+function extractMessageContent(message) {
+	const content = message.content;
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((part) => {
+		if (typeof part === "string") return part;
+		if ("text" in part && typeof part.text === "string") return part.text;
+		return "";
+	}).filter(Boolean).join("");
+	return "";
+}
+/**
+* Extract text content from an AgentMessage.
+*/
+function extractAgentMessageContent(message) {
+	const content = message.content;
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((part) => {
+		if (typeof part === "string") return part;
+		if ("text" in part && typeof part.text === "string") return part.text;
+		return "";
+	}).filter(Boolean).join("");
+	return "";
+}
+/**
+* Map ModelMessage role to memory entry type.
+*/
+function roleToEntryType(role) {
+	switch (role) {
+		case "assistant": return "assistant";
+		case "system": return "system";
+		case "tool": return "tool";
+		case "user":
+		default: return "user";
+	}
+}
+var BaseAgentMemoryManager = class {
+	async append(session, entry) {
+		const current = await this.load(session.sessionId) ?? this.bootstrapMemory(session);
+		const finalEntry = {
+			id: randomUUID(),
+			createdAt: entry.createdAt ?? /* @__PURE__ */ new Date(),
+			...entry
+		};
+		current.memory.entries.push(finalEntry);
+		await this.save(current);
+		return current;
+	}
+	async summarize(_session) {}
+	async prune(_session) {}
+	bootstrapMemory(session) {
+		return {
+			session,
+			memory: { entries: session.messages.map((message) => ({
+				id: randomUUID(),
+				createdAt: /* @__PURE__ */ new Date(),
+				type: roleToEntryType(message.role),
+				content: extractMessageContent(message)
+			})) }
+		};
+	}
+};
+function trackMessageInMemory(manager, session, message) {
+	if (!manager) return;
+	manager.append(session, {
+		type: message.role,
+		content: extractAgentMessageContent(message),
+		metadata: message.metadata
+	});
+}
+
+//#endregion
+export { BaseAgentMemoryManager, trackMessageInMemory };

package/dist/schema/index.js

@@ -1 +1,4 @@
-import{jsonSchemaToZod as e,jsonSchemaToZodSafe as t}from"./json-schema-to-zod.js";import{SchemaOutput as n,enumToChoiceOutput as r,jsonSchemaToArrayOutput as i,jsonSchemaToOutput as a,textOutput as o,zodToOutput as s}from"./schema-output.js";export{n as SchemaOutput,r as enumToChoiceOutput,i as jsonSchemaToArrayOutput,a as jsonSchemaToOutput,e as jsonSchemaToZod,t as jsonSchemaToZodSafe,o as textOutput,s as zodToOutput};
+import { jsonSchemaToZod, jsonSchemaToZodSafe } from "./json-schema-to-zod.js";
+import { SchemaOutput, enumToChoiceOutput, jsonSchemaToArrayOutput, jsonSchemaToOutput, textOutput, zodToOutput } from "./schema-output.js";
+
+export { SchemaOutput, enumToChoiceOutput, jsonSchemaToArrayOutput, jsonSchemaToOutput, jsonSchemaToZod, jsonSchemaToZodSafe, textOutput, zodToOutput };