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

package/dist/schema/json-schema-to-zod.js

@@ -1 +1,123 @@
-import{z as e}from"zod";function t(o){let s=o,c=t=>s.nullable?e.union([t,e.null()]):t;if(s.const!==void 0)return e.literal(s.const);if(s.enum){let t=s.enum;return c(e.enum(t.map(String)))}if(s.anyOf&&s.anyOf.length>0){let n=s.anyOf.map(e=>t(e));return n.length===1?n[0]:e.union([n[0],n[1],...n.slice(2)])}if(s.oneOf&&s.oneOf.length>0){let n=s.oneOf.map(e=>t(e));return n.length===1?n[0]:e.union([n[0],n[1],...n.slice(2)])}if(s.allOf&&s.allOf.length>0)return s.allOf.map(e=>t(e)).reduce((t,n)=>e.intersection(t,n));switch(s.type){case`string`:return c(n(s));case`number`:case`integer`:return c(r(s));case`boolean`:return c(e.boolean());case`null`:return e.null();case`array`:return c(i(s));case`object`:return c(a(s));default:return e.unknown()}}function n(t){let n=e.string();switch(t.description&&(n=n.describe(t.description)),t.format){case`email`:n=n.email();break;case`uri`:case`url`:n=n.url();break;case`uuid`:n=n.uuid();break;case`date-time`:n=n.datetime();break;case`date`:n=n.date();break}return t.minLength!==void 0&&(n=n.min(t.minLength)),t.maxLength!==void 0&&(n=n.max(t.maxLength)),t.pattern&&(n=n.regex(new RegExp(t.pattern))),n}function r(t){let n=t.type===`integer`?e.number().int():e.number();return t.description&&(n=n.describe(t.description)),t.minimum!==void 0&&(n=n.min(t.minimum)),t.maximum!==void 0&&(n=n.max(t.maximum)),n}function i(n){let r=n.items?t(n.items):e.unknown(),i=e.array(r);return n.description&&(i=i.describe(n.description)),i}function a(n){let r=n.properties??{},i=new Set(n.required??[]),a={};for(let[e,n]of Object.entries(r)){let r=t(n);a[e]=i.has(e)?r:r.optional()}let o=e.object(a);return n.description&&(o=o.describe(n.description)),o}function o(n){return!n||Object.keys(n).length===0?e.object({}):t(n)}export{t as jsonSchemaToZod,o as jsonSchemaToZodSafe};
+import { z } from "zod";
+
+//#region src/schema/json-schema-to-zod.ts
+/**
+* Convert a JSON Schema to a Zod schema.
+*
+* Supports common JSON Schema types and constraints:
+* - string, number, integer, boolean, null
+* - object with properties and required
+* - array with items
+* - enum and const
+* - anyOf, oneOf, allOf
+* - format constraints (email, uri, uuid, date-time)
+* - numeric constraints (minimum, maximum)
+* - string constraints (minLength, maxLength, pattern)
+*
+* @param schema - JSON Schema object
+* @returns Zod schema
+*/
+function jsonSchemaToZod(schema) {
+	const s = schema;
+	const makeNullable = (zodSchema) => {
+		return s.nullable ? z.union([zodSchema, z.null()]) : zodSchema;
+	};
+	if (s.const !== void 0) return z.literal(s.const);
+	if (s.enum) {
+		const values = s.enum;
+		return makeNullable(z.enum(values.map(String)));
+	}
+	if (s.anyOf && s.anyOf.length > 0) {
+		const schemas = s.anyOf.map((sub) => jsonSchemaToZod(sub));
+		if (schemas.length === 1) return schemas[0];
+		return z.union([
+			schemas[0],
+			schemas[1],
+			...schemas.slice(2)
+		]);
+	}
+	if (s.oneOf && s.oneOf.length > 0) {
+		const schemas = s.oneOf.map((sub) => jsonSchemaToZod(sub));
+		if (schemas.length === 1) return schemas[0];
+		return z.union([
+			schemas[0],
+			schemas[1],
+			...schemas.slice(2)
+		]);
+	}
+	if (s.allOf && s.allOf.length > 0) return s.allOf.map((sub) => jsonSchemaToZod(sub)).reduce((acc, curr) => z.intersection(acc, curr));
+	switch (s.type) {
+		case "string": return makeNullable(buildStringSchema(s));
+		case "number":
+		case "integer": return makeNullable(buildNumberSchema(s));
+		case "boolean": return makeNullable(z.boolean());
+		case "null": return z.null();
+		case "array": return makeNullable(buildArraySchema(s));
+		case "object": return makeNullable(buildObjectSchema(s));
+		default: return z.unknown();
+	}
+}
+function buildStringSchema(schema) {
+	let zodSchema = z.string();
+	if (schema.description) zodSchema = zodSchema.describe(schema.description);
+	switch (schema.format) {
+		case "email":
+			zodSchema = zodSchema.email();
+			break;
+		case "uri":
+		case "url":
+			zodSchema = zodSchema.url();
+			break;
+		case "uuid":
+			zodSchema = zodSchema.uuid();
+			break;
+		case "date-time":
+			zodSchema = zodSchema.datetime();
+			break;
+		case "date":
+			zodSchema = zodSchema.date();
+			break;
+	}
+	if (schema.minLength !== void 0) zodSchema = zodSchema.min(schema.minLength);
+	if (schema.maxLength !== void 0) zodSchema = zodSchema.max(schema.maxLength);
+	if (schema.pattern) zodSchema = zodSchema.regex(new RegExp(schema.pattern));
+	return zodSchema;
+}
+function buildNumberSchema(schema) {
+	let zodSchema = schema.type === "integer" ? z.number().int() : z.number();
+	if (schema.description) zodSchema = zodSchema.describe(schema.description);
+	if (schema.minimum !== void 0) zodSchema = zodSchema.min(schema.minimum);
+	if (schema.maximum !== void 0) zodSchema = zodSchema.max(schema.maximum);
+	return zodSchema;
+}
+function buildArraySchema(schema) {
+	const itemsSchema = schema.items ? jsonSchemaToZod(schema.items) : z.unknown();
+	let zodSchema = z.array(itemsSchema);
+	if (schema.description) zodSchema = zodSchema.describe(schema.description);
+	return zodSchema;
+}
+function buildObjectSchema(schema) {
+	const properties = schema.properties ?? {};
+	const required = new Set(schema.required ?? []);
+	const shape = {};
+	for (const [key, propSchema] of Object.entries(properties)) {
+		const zodProp = jsonSchemaToZod(propSchema);
+		shape[key] = required.has(key) ? zodProp : zodProp.optional();
+	}
+	let zodSchema = z.object(shape);
+	if (schema.description) zodSchema = zodSchema.describe(schema.description);
+	return zodSchema;
+}
+/**
+* Convert a JSON Schema to a Zod schema with a default empty object fallback.
+*
+* @param schema - Optional JSON Schema object
+* @returns Zod schema (defaults to empty object schema)
+*/
+function jsonSchemaToZodSafe(schema) {
+	if (!schema || Object.keys(schema).length === 0) return z.object({});
+	return jsonSchemaToZod(schema);
+}
+
+//#endregion
+export { jsonSchemaToZod, jsonSchemaToZodSafe };

package/dist/schema/schema-output.js

@@ -1 +1,64 @@
-import{jsonSchemaToZod as e}from"./json-schema-to-zod.js";import{Output as t}from"ai";import{z as n}from"zod";function r(n){let r=e(n);return t.object({schema:r})}function i(n){let r=e(n);return t.array({element:r})}function a(e){return t.choice({options:e})}function o(e){return t.object({schema:e})}function s(){return t.text()}const c={fromJsonSchema:r,arrayFromJsonSchema:i,fromEnum:a,fromZod:o,text:s};export{c as SchemaOutput,a as enumToChoiceOutput,i as jsonSchemaToArrayOutput,r as jsonSchemaToOutput,s as textOutput,o as zodToOutput};
+import { jsonSchemaToZod } from "./json-schema-to-zod.js";
+import { Output } from "ai";
+import { z } from "zod";
+
+//#region src/schema/schema-output.ts
+/**
+* Create an AI SDK Output.object from a JSON Schema.
+*
+* @param schema - JSON Schema object
+* @returns AI SDK Output configuration
+*/
+function jsonSchemaToOutput(schema) {
+	const zodSchema = jsonSchemaToZod(schema);
+	return Output.object({ schema: zodSchema });
+}
+/**
+* Create an AI SDK Output.array from a JSON Schema items definition.
+*
+* @param itemSchema - JSON Schema for array items
+* @returns AI SDK Output configuration
+*/
+function jsonSchemaToArrayOutput(itemSchema) {
+	const zodSchema = jsonSchemaToZod(itemSchema);
+	return Output.array({ element: zodSchema });
+}
+/**
+* Create an AI SDK Output.choice from enum values.
+*
+* @param choices - Array of choice values
+* @returns AI SDK Output configuration
+*/
+function enumToChoiceOutput(choices) {
+	return Output.choice({ options: choices });
+}
+/**
+* Create an AI SDK Output from a Zod schema directly.
+*
+* @param schema - Zod schema
+* @returns AI SDK Output configuration
+*/
+function zodToOutput(schema) {
+	return Output.object({ schema });
+}
+/**
+* Create a simple text output configuration.
+*
+* @returns AI SDK Output configuration for text
+*/
+function textOutput() {
+	return Output.text();
+}
+/**
+* Output builder that can be used fluently.
+*/
+const SchemaOutput = {
+	fromJsonSchema: jsonSchemaToOutput,
+	arrayFromJsonSchema: jsonSchemaToArrayOutput,
+	fromEnum: enumToChoiceOutput,
+	fromZod: zodToOutput,
+	text: textOutput
+};
+
+//#endregion
+export { SchemaOutput, enumToChoiceOutput, jsonSchemaToArrayOutput, jsonSchemaToOutput, textOutput, zodToOutput };

package/dist/session/index.js

@@ -1 +1,3 @@
-import{InMemorySessionStore as e,createInMemorySessionStore as t,generateSessionId as n}from"./store.js";export{e as InMemorySessionStore,t as createInMemorySessionStore,n as generateSessionId};
+import { InMemorySessionStore, createInMemorySessionStore, generateSessionId } from "./store.js";
+
+export { InMemorySessionStore, createInMemorySessionStore, generateSessionId };

package/dist/session/store.js

@@ -1 +1,78 @@
-var e=class{sessions=new Map;async get(e){return this.sessions.get(e)??null}async create(e){let t=new Date,n={...e,createdAt:t,updatedAt:t};return this.sessions.set(e.sessionId,n),n}async appendStep(e,t){let n=this.sessions.get(e);n&&(n.steps.push(t),n.updatedAt=new Date)}async appendMessage(e,t){let n=this.sessions.get(e);n&&(n.messages.push(t),n.updatedAt=new Date)}async update(e,t){let n=this.sessions.get(e);n&&Object.assign(n,t,{updatedAt:new Date})}async delete(e){return this.sessions.delete(e)}async listByAgent(e,t=100){let n=[];for(let r of this.sessions.values())if(r.agentId===e&&(n.push(r),n.length>=t))break;return n.sort((e,t)=>t.updatedAt.getTime()-e.updatedAt.getTime())}async listByTenant(e,t=100){let n=[];for(let r of this.sessions.values())if(r.tenantId===e&&(n.push(r),n.length>=t))break;return n.sort((e,t)=>t.updatedAt.getTime()-e.updatedAt.getTime())}clear(){this.sessions.clear()}};function t(){return new e}function n(){return`sess_${Date.now()}_${Math.random().toString(36).slice(2,11)}`}export{e as InMemorySessionStore,t as createInMemorySessionStore,n as generateSessionId};
+//#region src/session/store.ts
+/**
+* In-memory session store for development and testing.
+*/
+var InMemorySessionStore = class {
+	sessions = /* @__PURE__ */ new Map();
+	async get(sessionId) {
+		return this.sessions.get(sessionId) ?? null;
+	}
+	async create(session) {
+		const now = /* @__PURE__ */ new Date();
+		const fullSession = {
+			...session,
+			createdAt: now,
+			updatedAt: now
+		};
+		this.sessions.set(session.sessionId, fullSession);
+		return fullSession;
+	}
+	async appendStep(sessionId, step) {
+		const session = this.sessions.get(sessionId);
+		if (session) {
+			session.steps.push(step);
+			session.updatedAt = /* @__PURE__ */ new Date();
+		}
+	}
+	async appendMessage(sessionId, message) {
+		const session = this.sessions.get(sessionId);
+		if (session) {
+			session.messages.push(message);
+			session.updatedAt = /* @__PURE__ */ new Date();
+		}
+	}
+	async update(sessionId, updates) {
+		const session = this.sessions.get(sessionId);
+		if (session) Object.assign(session, updates, { updatedAt: /* @__PURE__ */ new Date() });
+	}
+	async delete(sessionId) {
+		return this.sessions.delete(sessionId);
+	}
+	async listByAgent(agentId, limit = 100) {
+		const results = [];
+		for (const session of this.sessions.values()) if (session.agentId === agentId) {
+			results.push(session);
+			if (results.length >= limit) break;
+		}
+		return results.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+	}
+	async listByTenant(tenantId, limit = 100) {
+		const results = [];
+		for (const session of this.sessions.values()) if (session.tenantId === tenantId) {
+			results.push(session);
+			if (results.length >= limit) break;
+		}
+		return results.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+	}
+	/**
+	* Clear all sessions (for testing).
+	*/
+	clear() {
+		this.sessions.clear();
+	}
+};
+/**
+* Create an in-memory session store.
+*/
+function createInMemorySessionStore() {
+	return new InMemorySessionStore();
+}
+/**
+* Generate a unique session ID.
+*/
+function generateSessionId() {
+	return `sess_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+
+//#endregion
+export { InMemorySessionStore, createInMemorySessionStore, generateSessionId };

package/dist/spec/index.js

@@ -1 +1,4 @@
-import{agentKey as e,defineAgent as t}from"./spec.js";import{AgentRegistry as n,createAgentRegistry as r}from"./registry.js";export{n as AgentRegistry,e as agentKey,r as createAgentRegistry,t as defineAgent};
+import { agentKey, defineAgent } from "./spec.js";
+import { AgentRegistry, createAgentRegistry } from "./registry.js";
+
+export { AgentRegistry, agentKey, createAgentRegistry, defineAgent };

package/dist/spec/registry.js

@@ -1 +1,116 @@
-import{agentKey as e}from"./spec.js";var t=class{specs=new Map;register(t){let n=e(t.meta);if(this.specs.has(n))throw Error(`Duplicate agent spec registered for ${n}`);return this.specs.set(n,t),this}unregister(e,t){return this.specs.delete(`${e}.v${t}`)}list(){return[...this.specs.values()]}listNames(){let e=new Set;for(let t of this.specs.values())e.add(t.meta.name);return[...e]}get(e,t){if(t!=null)return this.specs.get(`${e}.v${t}`);let n,r=-1/0;for(let t of this.specs.values())t.meta.name===e&&t.meta.version>r&&(n=t,r=t.meta.version);return n}require(e,t){let n=this.get(e,t);if(!n)throw Error(`Agent spec not found for ${e}${t==null?``:`.v${t}`}`);return n}has(e,t){return this.get(e,t)!==void 0}getVersions(e){let t=[];for(let n of this.specs.values())n.meta.name===e&&t.push(n);return t.sort((e,t)=>e.meta.version-t.meta.version)}clear(){this.specs.clear()}};function n(){return new t}export{t as AgentRegistry,n as createAgentRegistry};
+import { agentKey } from "./spec.js";
+
+//#region src/spec/registry.ts
+/**
+* Registry for managing agent specifications.
+*
+* Provides registration, lookup, and version management for agent specs.
+*/
+var AgentRegistry = class {
+	specs = /* @__PURE__ */ new Map();
+	/**
+	* Register an agent specification.
+	*
+	* @param spec - The agent specification to register
+	* @returns This registry for chaining
+	* @throws Error if the spec is already registered
+	*/
+	register(spec) {
+		const key = agentKey(spec.meta);
+		if (this.specs.has(key)) throw new Error(`Duplicate agent spec registered for ${key}`);
+		this.specs.set(key, spec);
+		return this;
+	}
+	/**
+	* Unregister an agent specification.
+	*
+	* @param name - Agent name
+	* @param version - Agent version
+	* @returns True if the spec was removed
+	*/
+	unregister(name, version) {
+		return this.specs.delete(`${name}.v${version}`);
+	}
+	/**
+	* List all registered agent specifications.
+	*/
+	list() {
+		return [...this.specs.values()];
+	}
+	/**
+	* List all unique agent names (without versions).
+	*/
+	listNames() {
+		const names = /* @__PURE__ */ new Set();
+		for (const spec of this.specs.values()) names.add(spec.meta.name);
+		return [...names];
+	}
+	/**
+	* Get an agent specification by name and optional version.
+	*
+	* @param name - Agent name
+	* @param version - Optional version. If omitted, returns the latest version.
+	* @returns The agent spec or undefined if not found
+	*/
+	get(name, version) {
+		if (version != null) return this.specs.get(`${name}.v${version}`);
+		let latest;
+		let maxVersion = -Infinity;
+		for (const spec of this.specs.values()) {
+			if (spec.meta.name !== name) continue;
+			if (spec.meta.version > maxVersion) {
+				latest = spec;
+				maxVersion = spec.meta.version;
+			}
+		}
+		return latest;
+	}
+	/**
+	* Get an agent specification or throw if not found.
+	*
+	* @param name - Agent name
+	* @param version - Optional version
+	* @returns The agent spec
+	* @throws Error if the spec is not found
+	*/
+	require(name, version) {
+		const spec = this.get(name, version);
+		if (!spec) throw new Error(`Agent spec not found for ${name}${version != null ? `.v${version}` : ""}`);
+		return spec;
+	}
+	/**
+	* Check if an agent is registered.
+	*
+	* @param name - Agent name
+	* @param version - Optional version
+	*/
+	has(name, version) {
+		return this.get(name, version) !== void 0;
+	}
+	/**
+	* Get all versions of an agent.
+	*
+	* @param name - Agent name
+	* @returns Array of specs sorted by version (ascending)
+	*/
+	getVersions(name) {
+		const versions = [];
+		for (const spec of this.specs.values()) if (spec.meta.name === name) versions.push(spec);
+		return versions.sort((a, b) => a.meta.version - b.meta.version);
+	}
+	/**
+	* Clear all registered specs.
+	*/
+	clear() {
+		this.specs.clear();
+	}
+};
+/**
+* Create a new agent registry.
+*/
+function createAgentRegistry() {
+	return new AgentRegistry();
+}
+
+//#endregion
+export { AgentRegistry, createAgentRegistry };

package/dist/spec/spec.js

@@ -1 +1,29 @@
-function e(e){if(!e.meta?.name)throw Error(`Agent name is required`);if(!Number.isFinite(e.meta.version))throw Error(`Agent ${e.meta.name} is missing a numeric version`);if(!e.instructions?.trim())throw Error(`Agent ${e.meta.name} requires instructions`);if(!e.tools?.length)throw Error(`Agent ${e.meta.name} must expose at least one tool`);let t=new Set;for(let n of e.tools){if(t.has(n.name))throw Error(`Agent ${e.meta.name} has duplicate tool name: ${n.name}`);t.add(n.name)}return Object.freeze(e)}function t(e){return`${e.name}.v${e.version}`}export{t as agentKey,e as defineAgent};
+//#region src/spec/spec.ts
+/**
+* Define and validate an agent specification.
+*
+* @param spec - The agent specification
+* @returns The frozen, validated specification
+* @throws Error if the specification is invalid
+*/
+function defineAgent(spec) {
+	if (!spec.meta?.name) throw new Error("Agent name is required");
+	if (!Number.isFinite(spec.meta.version)) throw new Error(`Agent ${spec.meta.name} is missing a numeric version`);
+	if (!spec.instructions?.trim()) throw new Error(`Agent ${spec.meta.name} requires instructions`);
+	if (!spec.tools?.length) throw new Error(`Agent ${spec.meta.name} must expose at least one tool`);
+	const toolNames = /* @__PURE__ */ new Set();
+	for (const tool of spec.tools) {
+		if (toolNames.has(tool.name)) throw new Error(`Agent ${spec.meta.name} has duplicate tool name: ${tool.name}`);
+		toolNames.add(tool.name);
+	}
+	return Object.freeze(spec);
+}
+/**
+* Generate a unique key for an agent spec.
+*/
+function agentKey(meta) {
+	return `${meta.name}.v${meta.version}`;
+}
+
+//#endregion
+export { agentKey, defineAgent };

package/dist/telemetry/adapter.js

@@ -1 +1,102 @@
-function e(e){let t=e.match(/^(.+)\.v(\d+)$/);return t?{name:t[1],version:parseInt(t[2],10)}:{name:e,version:1}}async function t(t,n,r,i){let{name:a,version:o}=e(n);for(let e of r.toolCalls??[]){let s={operation:{name:`${a}.${e.toolName}`,version:o},durationMs:i??0,success:r.toolResults?.some(t=>t.toolCallId===e.toolCallId&&t.output!==void 0)??!1,timestamp:new Date,metadata:{agentId:n,toolName:e.toolName,finishReason:r.finishReason}};await t.collect(s)}let s={operation:{name:a,version:o},durationMs:i??0,success:r.finishReason!==`error`,timestamp:new Date,metadata:{agentId:n,finishReason:r.finishReason,tokenUsage:r.usage,toolCallCount:r.toolCalls?.length??0}};await t.collect(s)}var n=class{samples=[];async collect(e){this.samples.push(e)}getSamples(){return[...this.samples]}getSamplesForOperation(e){return this.samples.filter(t=>t.operation.name===e)}clear(){this.samples.length=0}};function r(){return new n}const i={collect:async()=>{}};export{n as InMemoryTelemetryCollector,r as createInMemoryTelemetryCollector,i as noopTelemetryCollector,t as trackAgentStep};
+//#region src/telemetry/adapter.ts
+/**
+* Parse agent ID into name and version.
+*/
+function parseAgentId(agentId) {
+	const match = agentId.match(/^(.+)\.v(\d+)$/);
+	if (match) return {
+		name: match[1],
+		version: parseInt(match[2], 10)
+	};
+	return {
+		name: agentId,
+		version: 1
+	};
+}
+/**
+* Track an agent step for telemetry.
+*
+* Called from ContractSpecAgent.onStepFinish to feed metrics
+* to the evolution engine.
+*
+* @param collector - Telemetry collector
+* @param agentId - Agent identifier (e.g., "support.bot.v1")
+* @param step - AI SDK step result
+* @param durationMs - Optional step duration in milliseconds
+*/
+async function trackAgentStep(collector, agentId, step, durationMs) {
+	const { name, version } = parseAgentId(agentId);
+	for (const toolCall of step.toolCalls ?? []) {
+		const toolSample = {
+			operation: {
+				name: `${name}.${toolCall.toolName}`,
+				version
+			},
+			durationMs: durationMs ?? 0,
+			success: step.toolResults?.some((r) => r.toolCallId === toolCall.toolCallId && r.output !== void 0) ?? false,
+			timestamp: /* @__PURE__ */ new Date(),
+			metadata: {
+				agentId,
+				toolName: toolCall.toolName,
+				finishReason: step.finishReason
+			}
+		};
+		await collector.collect(toolSample);
+	}
+	const stepSample = {
+		operation: {
+			name,
+			version
+		},
+		durationMs: durationMs ?? 0,
+		success: step.finishReason !== "error",
+		timestamp: /* @__PURE__ */ new Date(),
+		metadata: {
+			agentId,
+			finishReason: step.finishReason,
+			tokenUsage: step.usage,
+			toolCallCount: step.toolCalls?.length ?? 0
+		}
+	};
+	await collector.collect(stepSample);
+}
+/**
+* In-memory telemetry collector for testing.
+*/
+var InMemoryTelemetryCollector = class {
+	samples = [];
+	async collect(sample) {
+		this.samples.push(sample);
+	}
+	/**
+	* Get all collected samples.
+	*/
+	getSamples() {
+		return [...this.samples];
+	}
+	/**
+	* Get samples for a specific operation.
+	*/
+	getSamplesForOperation(operationName) {
+		return this.samples.filter((s) => s.operation.name === operationName);
+	}
+	/**
+	* Clear all samples.
+	*/
+	clear() {
+		this.samples.length = 0;
+	}
+};
+/**
+* Create an in-memory telemetry collector.
+*/
+function createInMemoryTelemetryCollector() {
+	return new InMemoryTelemetryCollector();
+}
+/**
+* No-op telemetry collector that discards all metrics.
+*/
+const noopTelemetryCollector = { collect: async () => {} };
+
+//#endregion
+export { InMemoryTelemetryCollector, createInMemoryTelemetryCollector, noopTelemetryCollector, trackAgentStep };

package/dist/telemetry/index.js

@@ -1 +1,3 @@
-import{InMemoryTelemetryCollector as e,createInMemoryTelemetryCollector as t,noopTelemetryCollector as n,trackAgentStep as r}from"./adapter.js";export{e as InMemoryTelemetryCollector,t as createInMemoryTelemetryCollector,n as noopTelemetryCollector,r as trackAgentStep};
+import { InMemoryTelemetryCollector, createInMemoryTelemetryCollector, noopTelemetryCollector, trackAgentStep } from "./adapter.js";
+
+export { InMemoryTelemetryCollector, createInMemoryTelemetryCollector, noopTelemetryCollector, trackAgentStep };

package/dist/tools/index.js

@@ -1 +1,6 @@
-import{buildToolHandlers as e,createToolHandler as t,specToolToAISDKTool as n,specToolsToAISDKTools as r}from"./tool-adapter.js";import{createKnowledgeQueryTool as i}from"./knowledge-tool.js";import{createMcpToolsets as a,mcpServerToTools as o}from"./mcp-client.js";import{agentToMcpServer as s,createAgentMcpServer as c}from"./mcp-server.js";export{s as agentToMcpServer,e as buildToolHandlers,c as createAgentMcpServer,i as createKnowledgeQueryTool,a as createMcpToolsets,t as createToolHandler,o as mcpServerToTools,n as specToolToAISDKTool,r as specToolsToAISDKTools};
+import { buildToolHandlers, createToolHandler, specToolToAISDKTool, specToolsToAISDKTools } from "./tool-adapter.js";
+import { createKnowledgeQueryTool } from "./knowledge-tool.js";
+import { createMcpToolsets, mcpServerToTools } from "./mcp-client.js";
+import { agentToMcpServer, createAgentMcpServer } from "./mcp-server.js";
+
+export { agentToMcpServer, buildToolHandlers, createAgentMcpServer, createKnowledgeQueryTool, createMcpToolsets, createToolHandler, mcpServerToTools, specToolToAISDKTool, specToolsToAISDKTools };

package/dist/tools/knowledge-tool.js

@@ -1,9 +1,53 @@
-import{tool as e}from"ai";import*as t from"zod";function n(n,r){let i=r.filter(e=>!e.required).map(e=>e.key).filter(e=>n.supportsSpace(e));return i.length===0?null:e({description:`Query knowledge bases for relevant information. Use this tool when you need to look up specific information that may not be in your context.
+import { tool } from "ai";
+import * as z$1 from "zod";
 
-Available knowledge spaces:
-${r.filter(e=>!e.required&&n.supportsSpace(e.key)).map(e=>`- ${e.key}: ${e.instructions??`Knowledge space`}`).join(`
-`)}`,inputSchema:t.object({query:t.string().describe(`The question or search query to find relevant information`),spaceKey:t.enum(i).optional().describe(`Specific knowledge space to query. If omitted, searches all available spaces.`),topK:t.number().optional().default(5).describe(`Maximum number of results to return`)}),execute:async({query:e,spaceKey:t,topK:r})=>{let a=t?[t]:i,o=[];for(let t of a)try{let i=await n.retrieve(e,{spaceKey:t,topK:r??5});for(let e of i)o.push({space:t,content:e.content,score:e.score})}catch(e){console.warn(`Failed to query knowledge space ${t}:`,e)}return o.length===0?`No relevant information found in the knowledge bases.`:(o.sort((e,t)=>t.score-e.score),o.slice(0,r??5).map((e,t)=>`[Source ${t+1} - ${e.space}] (relevance: ${(e.score*100).toFixed(0)}%)\n${e.content}`).join(`
+//#region src/tools/knowledge-tool.ts
+/**
+* Create a knowledge query tool for dynamic RAG.
+*
+* This tool allows the agent to query optional knowledge spaces
+* at runtime. Required knowledge is injected statically via
+* the knowledge injector.
+*
+* @param retriever - The knowledge retriever to use
+* @param knowledgeRefs - Knowledge references from the agent spec
+* @returns AI SDK CoreTool for knowledge queries
+*/
+function createKnowledgeQueryTool(retriever, knowledgeRefs) {
+	const optionalSpaces = knowledgeRefs.filter((k) => !k.required).map((k) => k.key).filter((key) => retriever.supportsSpace(key));
+	if (optionalSpaces.length === 0) return null;
+	return tool({
+		description: `Query knowledge bases for relevant information. Use this tool when you need to look up specific information that may not be in your context.
 
----
+Available knowledge spaces:
+${knowledgeRefs.filter((k) => !k.required && retriever.supportsSpace(k.key)).map((k) => `- ${k.key}: ${k.instructions ?? "Knowledge space"}`).join("\n")}`,
+		inputSchema: z$1.object({
+			query: z$1.string().describe("The question or search query to find relevant information"),
+			spaceKey: z$1.enum(optionalSpaces).optional().describe("Specific knowledge space to query. If omitted, searches all available spaces."),
+			topK: z$1.number().optional().default(5).describe("Maximum number of results to return")
+		}),
+		execute: async ({ query, spaceKey, topK }) => {
+			const spacesToSearch = spaceKey ? [spaceKey] : optionalSpaces;
+			const allResults = [];
+			for (const space of spacesToSearch) try {
+				const results = await retriever.retrieve(query, {
+					spaceKey: space,
+					topK: topK ?? 5
+				});
+				for (const result of results) allResults.push({
+					space,
+					content: result.content,
+					score: result.score
+				});
+			} catch (error) {
+				console.warn(`Failed to query knowledge space ${space}:`, error);
+			}
+			if (allResults.length === 0) return "No relevant information found in the knowledge bases.";
+			allResults.sort((a, b) => b.score - a.score);
+			return allResults.slice(0, topK ?? 5).map((r, i) => `[Source ${i + 1} - ${r.space}] (relevance: ${(r.score * 100).toFixed(0)}%)\n${r.content}`).join("\n\n---\n\n");
+		}
+	});
+}
 
-`))}})}export{n as createKnowledgeQueryTool};
+//#endregion
+export { createKnowledgeQueryTool };

package/dist/tools/mcp-client.js

@@ -1 +1,57 @@
-import{experimental_createMCPClient as e}from"@ai-sdk/mcp";import{Experimental_StdioMCPTransport as t}from"@ai-sdk/mcp/mcp-stdio";async function n(n){let r=await e({transport:new t({command:n.command,args:n.args,env:n.env})});return{tools:await r.tools(),cleanup:()=>r.close()}}async function r(e){let t=await Promise.all(e.map(n)),r={};for(let e of t)Object.assign(r,e.tools);return{tools:r,cleanup:async()=>{await Promise.all(t.map(e=>e.cleanup()))}}}export{r as createMcpToolsets,n as mcpServerToTools};
+import { experimental_createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+
+//#region src/tools/mcp-client.ts
+/**
+* Create AI SDK tools from an MCP server.
+*
+* This adapter allows ContractSpec agents to consume tools
+* from external MCP servers (e.g., filesystem, database, etc.).
+*
+* @param config - MCP server configuration
+* @returns Tools and cleanup function
+*
+* @example
+* ```typescript
+* const { tools, cleanup } = await mcpServerToTools({
+*   name: 'filesystem',
+*   command: 'npx',
+*   args: ['-y', '@modelcontextprotocol/server-filesystem', '/path'],
+* });
+*
+* // Use tools in agent...
+*
+* await cleanup();
+* ```
+*/
+async function mcpServerToTools(config) {
+	const client = await experimental_createMCPClient({ transport: new Experimental_StdioMCPTransport({
+		command: config.command,
+		args: config.args,
+		env: config.env
+	}) });
+	return {
+		tools: await client.tools(),
+		cleanup: () => client.close()
+	};
+}
+/**
+* Create multiple MCP tool sets from configurations.
+*
+* @param configs - Array of MCP server configurations
+* @returns Combined tools and cleanup function
+*/
+async function createMcpToolsets(configs) {
+	const results = await Promise.all(configs.map(mcpServerToTools));
+	const combinedTools = {};
+	for (const result of results) Object.assign(combinedTools, result.tools);
+	return {
+		tools: combinedTools,
+		cleanup: async () => {
+			await Promise.all(results.map((r) => r.cleanup()));
+		}
+	};
+}
+
+//#endregion
+export { createMcpToolsets, mcpServerToTools };