knolo-core 0.3.0 → 3.1.1

package/dist/builder.js

@@ -8,6 +8,7 @@ import { buildIndex } from './indexer.js';
 import { tokenize } from './tokenize.js';
 import { getTextEncoder } from './utils/utf8.js';
 import { encodeScaleF16, quantizeEmbeddingInt8L2Norm } from './semantic.js';
+import { validateAgentRegistry } from './agent.js';
 export async function buildPack(docs, opts = {}) {
     const normalizedDocs = validateDocs(docs);
     // Prepare blocks (strip MD) and carry heading/docId for optional boosts.
@@ -21,6 +22,7 @@ export async function buildPack(docs, opts = {}) {
     const blockTokenLens = blocks.map((b) => tokenize(b.text).length);
     const totalTokens = blockTokenLens.reduce((sum, len) => sum + len, 0);
     const avgBlockLen = blocks.length ? totalTokens / blocks.length : 1;
+    const agents = normalizeAgents(opts.agents);
     const meta = {
         version: 3,
         stats: {
@@ -29,6 +31,7 @@ export async function buildPack(docs, opts = {}) {
             terms: lexicon.length,
             avgBlockLen,
         },
+        ...(agents ? { agents } : {}),
     };
     // Persist blocks as objects to optionally carry heading/docId/token length.
     const blocksPayload = blocks.map((b, i) => ({
@@ -47,12 +50,18 @@ export async function buildPack(docs, opts = {}) {
     const semanticSection = semanticEnabled && opts.semantic
         ? buildSemanticSection(blocks.length, opts.semantic)
         : undefined;
-    const semBytes = semanticSection ? enc.encode(JSON.stringify(semanticSection.semJson)) : undefined;
+    const semBytes = semanticSection
+        ? enc.encode(JSON.stringify(semanticSection.semJson))
+        : undefined;
     const semBlob = semanticSection?.semBlob;
-    const totalLength = 4 + metaBytes.length +
-        4 + lexBytes.length +
-        4 + postings.length * 4 +
-        4 + blocksBytes.length +
+    const totalLength = 4 +
+        metaBytes.length +
+        4 +
+        lexBytes.length +
+        4 +
+        postings.length * 4 +
+        4 +
+        blocksBytes.length +
         (semanticEnabled && semBytes && semBlob
             ? 4 + semBytes.length + 4 + semBlob.length
             : 0);
@@ -92,6 +101,15 @@ export async function buildPack(docs, opts = {}) {
     }
     return out;
 }
+function normalizeAgents(input) {
+    if (!input)
+        return undefined;
+    const registry = Array.isArray(input)
+        ? { version: 1, agents: input }
+        : input;
+    validateAgentRegistry(registry);
+    return registry;
+}
 function buildSemanticSection(blockCount, semantic) {
     const { embeddings } = semantic;
     if (!Array.isArray(embeddings) || embeddings.length !== blockCount) {
@@ -133,7 +151,11 @@ function buildSemanticSection(blockCount, semantic) {
         perVectorScale: true,
         blocks: {
             vectors: { byteOffset: vecByteOffset, length: vecs.length },
-            scales: { byteOffset: scalesByteOffset, length: scales.length, encoding: 'float16' },
+            scales: {
+                byteOffset: scalesByteOffset,
+                length: scales.length,
+                encoding: 'float16',
+            },
         },
     };
     return { semJson, semBlob };

package/dist/index.d.ts

@@ -1,9 +1,21 @@
 export { mountPack, hasSemantic } from './pack.js';
-export { query, lexConfidence, validateSemanticQueryOptions } from './query.js';
+export { query, lexConfidence, validateQueryOptions, validateSemanticQueryOptions, } from './query.js';
 export { makeContextPatch } from './patch.js';
 export { buildPack } from './builder.js';
-export { quantizeEmbeddingInt8L2Norm, encodeScaleF16, decodeScaleF16 } from './semantic.js';
+export { quantizeEmbeddingInt8L2Norm, encodeScaleF16, decodeScaleF16, } from './semantic.js';
+export { listAgents, getAgent, resolveAgent, buildSystemPrompt, isToolAllowed, assertToolAllowed, validateAgentRegistry, validateAgentDefinition, } from './agent.js';
 export type { MountOptions, PackMeta, Pack } from './pack.js';
 export type { QueryOptions, Hit } from './query.js';
 export type { ContextPatch } from './patch.js';
 export type { BuildInputDoc, BuildPackOptions } from './builder.js';
+export type { AgentPromptTemplate, AgentToolPolicy, AgentRetrievalDefaults, AgentDefinitionV1, AgentRegistry, ResolveAgentInput, ResolvedAgent, } from './agent.js';
+export { parseToolCallV1FromText } from './tool_parse.js';
+export { nowIso, createTrace } from './trace.js';
+export { assertToolCallAllowed } from './tool_gate.js';
+export { getAgentRoutingProfileV1, getPackRoutingProfilesV1, } from './routing_profile.js';
+export { isRouteDecisionV1, validateRouteDecisionV1, selectAgentIdFromRouteDecisionV1, } from './router.js';
+export { isToolCallV1, isToolResultV1 } from './tools.js';
+export type { ToolId, ToolCallV1, ToolResultErrorV1, ToolResultV1, ToolSpecV1, } from './tools.js';
+export type { TraceEventV1 } from './trace.js';
+export type { AgentRoutingProfileV1 } from './routing_profile.js';
+export type { RouteCandidateV1, RouteDecisionV1 } from './router.js';

package/dist/index.js

@@ -1,6 +1,13 @@
 // src/index.ts
 export { mountPack, hasSemantic } from './pack.js';
-export { query, lexConfidence, validateSemanticQueryOptions } from './query.js';
+export { query, lexConfidence, validateQueryOptions, validateSemanticQueryOptions, } from './query.js';
 export { makeContextPatch } from './patch.js';
 export { buildPack } from './builder.js';
-export { quantizeEmbeddingInt8L2Norm, encodeScaleF16, decodeScaleF16 } from './semantic.js';
+export { quantizeEmbeddingInt8L2Norm, encodeScaleF16, decodeScaleF16, } from './semantic.js';
+export { listAgents, getAgent, resolveAgent, buildSystemPrompt, isToolAllowed, assertToolAllowed, validateAgentRegistry, validateAgentDefinition, } from './agent.js';
+export { parseToolCallV1FromText } from './tool_parse.js';
+export { nowIso, createTrace } from './trace.js';
+export { assertToolCallAllowed } from './tool_gate.js';
+export { getAgentRoutingProfileV1, getPackRoutingProfilesV1, } from './routing_profile.js';
+export { isRouteDecisionV1, validateRouteDecisionV1, selectAgentIdFromRouteDecisionV1, } from './router.js';
+export { isToolCallV1, isToolResultV1 } from './tools.js';

package/dist/pack.d.ts

@@ -1,3 +1,4 @@
+import type { AgentRegistry } from './agent.js';
 export type MountOptions = {
     src: string | ArrayBufferLike | Uint8Array;
 };
@@ -9,6 +10,7 @@ export type PackMeta = {
         terms: number;
         avgBlockLen?: number;
     };
+    agents?: AgentRegistry;
 };
 export type Pack = {
     meta: PackMeta;

package/dist/pack.js

@@ -7,6 +7,7 @@
  * Includes RN/Expo-safe TextDecoder via ponyfill.
  */
 import { getTextDecoder } from './utils/utf8.js';
+import { validateAgentRegistry } from './agent.js';
 export function hasSemantic(pack) {
     return Boolean(pack.semantic && pack.semantic.dims > 0 && pack.semantic.vecs.length > 0);
 }
@@ -21,6 +22,9 @@ export async function mountPack(opts) {
     const metaJson = dec.decode(new Uint8Array(buf, offset, metaLen));
     offset += metaLen;
     const meta = JSON.parse(metaJson);
+    if (meta.agents) {
+        validateAgentRegistry(meta.agents);
+    }
     // lexicon
     const lexLen = dv.getUint32(offset, true);
     offset += 4;
@@ -89,7 +93,17 @@ export async function mountPack(opts) {
         const semBlob = new Uint8Array(buf, offset, semBlobLen);
         semantic = parseSemanticSection(sem, semBlob);
     }
-    return { meta, lexicon, postings, blocks, headings, docIds, namespaces, blockTokenLens, semantic };
+    return {
+        meta,
+        lexicon,
+        postings,
+        blocks,
+        headings,
+        docIds,
+        namespaces,
+        blockTokenLens,
+        semantic,
+    };
 }
 function parseSemanticSection(sem, blob) {
     const vectors = sem?.blocks?.vectors;
@@ -133,12 +147,17 @@ async function resolveToBuffer(src) {
     return src;
 }
 function isNodeRuntime() {
-    return typeof process !== 'undefined' && !!process.versions?.node;
+    const p = globalThis
+        .process;
+    return !!p?.versions?.node;
 }
 function isLikelyLocalPath(value) {
     if (value.startsWith('file://'))
         return true;
-    if (value.startsWith('./') || value.startsWith('../') || value.startsWith('/') || value.startsWith('~'))
+    if (value.startsWith('./') ||
+        value.startsWith('../') ||
+        value.startsWith('/') ||
+        value.startsWith('~'))
         return true;
     if (/^[A-Za-z]:[\\/]/.test(value))
         return true; // Windows absolute path

package/dist/query.d.ts

@@ -26,6 +26,7 @@ export type QueryOptions = {
         force?: boolean;
     };
 };
+export declare function validateQueryOptions(opts?: QueryOptions): void;
 export declare function validateSemanticQueryOptions(options?: QueryOptions["semantic"]): void;
 export type Hit = {
     blockId: number;

package/dist/query.js

@@ -14,6 +14,40 @@ import { minCoverSpan, proximityMultiplier } from "./quality/proximity.js";
 import { diversifyAndDedupe } from "./quality/diversify.js";
 import { knsSignature, knsDistance } from "./quality/signature.js";
 import { decodeScaleF16, quantizeEmbeddingInt8L2Norm } from "./semantic.js";
+export function validateQueryOptions(opts) {
+    if (!opts)
+        return;
+    if (opts.topK !== undefined && (!Number.isInteger(opts.topK) || opts.topK < 1)) {
+        throw new Error("query(...): topK must be a positive integer.");
+    }
+    if (opts.minScore !== undefined && (!Number.isFinite(opts.minScore) || opts.minScore < 0)) {
+        throw new Error("query(...): minScore must be a finite number >= 0.");
+    }
+    if (opts.requirePhrases !== undefined && (!Array.isArray(opts.requirePhrases) || opts.requirePhrases.some((p) => typeof p !== "string"))) {
+        throw new Error("query(...): requirePhrases must be an array of strings when provided.");
+    }
+    validateStringOrStringArrayOption("namespace", opts.namespace);
+    validateStringOrStringArrayOption("source", opts.source);
+    if (opts.queryExpansion) {
+        const qe = opts.queryExpansion;
+        if (qe.enabled !== undefined && typeof qe.enabled !== "boolean") {
+            throw new Error("query(...): queryExpansion.enabled must be a boolean when provided.");
+        }
+        if (qe.docs !== undefined && (!Number.isInteger(qe.docs) || qe.docs < 1)) {
+            throw new Error("query(...): queryExpansion.docs must be a positive integer.");
+        }
+        if (qe.terms !== undefined && (!Number.isInteger(qe.terms) || qe.terms < 1)) {
+            throw new Error("query(...): queryExpansion.terms must be a positive integer.");
+        }
+        if (qe.weight !== undefined && (!Number.isFinite(qe.weight) || qe.weight < 0)) {
+            throw new Error("query(...): queryExpansion.weight must be a finite number >= 0.");
+        }
+        if (qe.minTermLength !== undefined && (!Number.isInteger(qe.minTermLength) || qe.minTermLength < 1)) {
+            throw new Error("query(...): queryExpansion.minTermLength must be a positive integer.");
+        }
+    }
+    validateSemanticQueryOptions(opts.semantic);
+}
 export function validateSemanticQueryOptions(options) {
     if (!options)
         return;
@@ -48,7 +82,7 @@ export function validateSemanticQueryOptions(options) {
     }
 }
 export function query(pack, q, opts = {}) {
-    validateSemanticQueryOptions(opts.semantic);
+    validateQueryOptions(opts);
     const topK = opts.topK ?? 10;
     const minScore = Number.isFinite(opts.minScore) ? Math.max(0, opts.minScore) : 0;
     const expansionOpts = {
@@ -419,3 +453,11 @@ function normalizeSourceFilter(input) {
     const values = Array.isArray(input) ? input : [input];
     return new Set(values.map((v) => normalize(v)).filter(Boolean));
 }
+function validateStringOrStringArrayOption(name, value) {
+    if (value === undefined)
+        return;
+    const valid = typeof value === "string" || (Array.isArray(value) && value.every((entry) => typeof entry === "string"));
+    if (!valid) {
+        throw new Error(`query(...): ${name} must be a string or an array of strings when provided.`);
+    }
+}

package/dist/router.d.ts

@@ -0,0 +1,28 @@
+import type { AgentDefinitionV1 } from './agent.js';
+export interface RouteCandidateV1 {
+    agentId: string;
+    score: number;
+    why?: string;
+}
+export interface RouteDecisionV1 {
+    type: 'route_decision';
+    intent?: string;
+    entities?: Record<string, unknown>;
+    candidates: RouteCandidateV1[];
+    selected: string;
+    needsTools?: string[];
+    risk?: 'low' | 'med' | 'high';
+}
+export declare function isRouteDecisionV1(x: unknown): x is RouteDecisionV1;
+export declare function validateRouteDecisionV1(decision: RouteDecisionV1, agentRegistry: Record<string, AgentDefinitionV1>): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function selectAgentIdFromRouteDecisionV1(decision: RouteDecisionV1, agentRegistry: Record<string, AgentDefinitionV1>, opts?: {
+    fallbackAgentId?: string;
+}): {
+    agentId: string;
+    reason: 'selected' | 'top_candidate' | 'fallback';
+};

package/dist/router.js

@@ -0,0 +1,74 @@
+export function isRouteDecisionV1(x) {
+    if (!x || typeof x !== 'object')
+        return false;
+    const v = x;
+    if (v.type !== 'route_decision')
+        return false;
+    if (typeof v.selected !== 'string' || !v.selected.trim())
+        return false;
+    if (!Array.isArray(v.candidates) || v.candidates.length < 1)
+        return false;
+    if (v.needsTools !== undefined &&
+        (!Array.isArray(v.needsTools) ||
+            v.needsTools.some((toolId) => typeof toolId !== 'string'))) {
+        return false;
+    }
+    for (const candidate of v.candidates) {
+        if (!candidate || typeof candidate !== 'object')
+            return false;
+        const c = candidate;
+        if (typeof c.agentId !== 'string' || !c.agentId.trim())
+            return false;
+        if (typeof c.score !== 'number' || !Number.isFinite(c.score))
+            return false;
+        if (c.score < 0 || c.score > 1)
+            return false;
+        if (c.why !== undefined && typeof c.why !== 'string')
+            return false;
+    }
+    return true;
+}
+export function validateRouteDecisionV1(decision, agentRegistry) {
+    if (!agentRegistry[decision.selected]) {
+        return {
+            ok: false,
+            error: `selected agent is not registered: ${decision.selected}`,
+        };
+    }
+    const seen = new Set();
+    for (const candidate of decision.candidates) {
+        if (seen.has(candidate.agentId)) {
+            return {
+                ok: false,
+                error: `duplicate candidate agentId: ${candidate.agentId}`,
+            };
+        }
+        seen.add(candidate.agentId);
+        if (!agentRegistry[candidate.agentId]) {
+            return {
+                ok: false,
+                error: `candidate agent is not registered: ${candidate.agentId}`,
+            };
+        }
+    }
+    return { ok: true };
+}
+export function selectAgentIdFromRouteDecisionV1(decision, agentRegistry, opts = {}) {
+    if (agentRegistry[decision.selected]) {
+        return { agentId: decision.selected, reason: 'selected' };
+    }
+    const sortedCandidates = [...decision.candidates].sort((a, b) => b.score - a.score || a.agentId.localeCompare(b.agentId));
+    for (const candidate of sortedCandidates) {
+        if (agentRegistry[candidate.agentId]) {
+            return { agentId: candidate.agentId, reason: 'top_candidate' };
+        }
+    }
+    if (opts.fallbackAgentId && agentRegistry[opts.fallbackAgentId]) {
+        return { agentId: opts.fallbackAgentId, reason: 'fallback' };
+    }
+    const defaultAgentId = Object.keys(agentRegistry).sort()[0];
+    if (defaultAgentId) {
+        return { agentId: defaultAgentId, reason: 'fallback' };
+    }
+    return { agentId: '', reason: 'fallback' };
+}

package/dist/routing_profile.d.ts

@@ -0,0 +1,19 @@
+import type { AgentDefinitionV1 } from './agent.js';
+import type { Pack } from './pack.js';
+export interface AgentRoutingProfileV1 {
+    agentId: string;
+    namespace?: string;
+    heading?: string;
+    description?: string;
+    tags: string[];
+    examples: string[];
+    capabilities: string[];
+    toolPolicy?: unknown;
+    toolPolicySummary?: {
+        mode: 'allow_all' | 'deny_all' | 'mixed' | 'unknown';
+        allowed?: string[];
+        denied?: string[];
+    };
+}
+export declare function getAgentRoutingProfileV1(agent: AgentDefinitionV1): AgentRoutingProfileV1;
+export declare function getPackRoutingProfilesV1(pack: Pack): AgentRoutingProfileV1[];

package/dist/routing_profile.js

@@ -0,0 +1,102 @@
+const MAX_DISCOVERABILITY_ITEMS = 20;
+export function getAgentRoutingProfileV1(agent) {
+    const metadata = agent.metadata ?? {};
+    const heading = getStringMetadata(metadata, 'heading');
+    const namespace = getPrimaryNamespace(agent);
+    return {
+        agentId: agent.id,
+        namespace,
+        heading,
+        description: agent.description,
+        tags: parseDiscoverabilityList(metadata.tags),
+        examples: parseDiscoverabilityList(metadata.examples),
+        capabilities: parseDiscoverabilityList(metadata.capabilities),
+        toolPolicy: agent.toolPolicy,
+        toolPolicySummary: summarizeToolPolicy(agent.toolPolicy),
+    };
+}
+export function getPackRoutingProfilesV1(pack) {
+    const agents = pack.meta.agents?.agents ?? [];
+    return agents.map((agent) => getAgentRoutingProfileV1(agent));
+}
+function getPrimaryNamespace(agent) {
+    const first = agent.retrievalDefaults.namespace[0];
+    if (typeof first === 'string' && first.trim()) {
+        return first;
+    }
+    return undefined;
+}
+function getStringMetadata(metadata, key) {
+    const value = metadata[key];
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim();
+    return normalized ? normalized : undefined;
+}
+function parseDiscoverabilityList(value) {
+    if (typeof value !== 'string')
+        return [];
+    const raw = value.trim();
+    if (!raw)
+        return [];
+    let parsed;
+    if (raw.startsWith('[')) {
+        parsed = parseJsonArrayString(raw);
+    }
+    else if (raw.includes('\n')) {
+        parsed = raw.split('\n');
+    }
+    else {
+        parsed = raw.split(',');
+    }
+    const deduped = [];
+    const seen = new Set();
+    for (const item of parsed) {
+        const normalized = item.trim();
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        deduped.push(normalized);
+        if (deduped.length >= MAX_DISCOVERABILITY_ITEMS)
+            break;
+    }
+    return deduped;
+}
+function parseJsonArrayString(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((item) => typeof item === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+function summarizeToolPolicy(policy) {
+    if (!policy) {
+        return {
+            mode: 'allow_all',
+        };
+    }
+    if (!Array.isArray(policy.tools)) {
+        return {
+            mode: 'unknown',
+        };
+    }
+    if (policy.mode === 'allow') {
+        return {
+            mode: 'mixed',
+            allowed: policy.tools,
+        };
+    }
+    if (policy.mode === 'deny') {
+        return {
+            mode: 'mixed',
+            denied: policy.tools,
+        };
+    }
+    return {
+        mode: 'unknown',
+    };
+}

package/dist/tool_gate.d.ts

@@ -0,0 +1,3 @@
+import { type AgentDefinitionV1 } from './agent.js';
+import { type ToolCallV1 } from './tools.js';
+export declare function assertToolCallAllowed(agent: AgentDefinitionV1, call: ToolCallV1): void;

package/dist/tool_gate.js

@@ -0,0 +1,8 @@
+import { assertToolAllowed } from './agent.js';
+import { isToolCallV1 } from './tools.js';
+export function assertToolCallAllowed(agent, call) {
+    if (!isToolCallV1(call)) {
+        throw new Error('tool call must be a valid ToolCallV1 object.');
+    }
+    assertToolAllowed(agent, call.tool);
+}

package/dist/tool_parse.d.ts

@@ -0,0 +1,2 @@
+import { type ToolCallV1 } from './tools.js';
+export declare function parseToolCallV1FromText(text: string): ToolCallV1 | null;

package/dist/tool_parse.js

@@ -0,0 +1,102 @@
+import { isToolCallV1 } from './tools.js';
+function tryParseJson(input) {
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return null;
+    }
+}
+function findBalancedJsonObject(text) {
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === '{') {
+            if (depth === 0)
+                start = i;
+            depth += 1;
+            continue;
+        }
+        if (char === '}') {
+            if (depth === 0)
+                continue;
+            depth -= 1;
+            if (depth === 0 && start >= 0) {
+                return text.slice(start, i + 1);
+            }
+        }
+    }
+    return null;
+}
+function parseToolCallCandidate(candidate) {
+    const value = tryParseJson(candidate);
+    return isToolCallV1(value) ? value : null;
+}
+function parseFromFencedBlock(text) {
+    const fencedRegex = /```(?:json)?\s*([\s\S]*?)```/gi;
+    let match;
+    while ((match = fencedRegex.exec(text)) !== null) {
+        const parsed = parseToolCallCandidate(match[1].trim());
+        if (parsed)
+            return parsed;
+    }
+    return null;
+}
+function parseFromMarkerLine(text) {
+    const lines = text.split(/\r?\n/);
+    for (const line of lines) {
+        const markerIndex = line.indexOf('TOOL_CALL:');
+        if (markerIndex === -1)
+            continue;
+        const tail = line.slice(markerIndex + 'TOOL_CALL:'.length).trim();
+        if (!tail)
+            continue;
+        const objectText = findBalancedJsonObject(tail) ?? tail;
+        const parsed = parseToolCallCandidate(objectText);
+        if (parsed)
+            return parsed;
+    }
+    return null;
+}
+function parseFirstJsonObject(text) {
+    const objectText = findBalancedJsonObject(text);
+    if (!objectText)
+        return null;
+    return tryParseJson(objectText);
+}
+export function parseToolCallV1FromText(text) {
+    if (typeof text !== 'string' || !text.trim())
+        return null;
+    const whole = parseToolCallCandidate(text.trim());
+    if (whole)
+        return whole;
+    const fenced = parseFromFencedBlock(text);
+    if (fenced)
+        return fenced;
+    const marker = parseFromMarkerLine(text);
+    if (marker)
+        return marker;
+    const firstObject = parseFirstJsonObject(text);
+    return isToolCallV1(firstObject) ? firstObject : null;
+}

package/dist/tools.d.ts

@@ -0,0 +1,27 @@
+export type ToolId = string;
+export interface ToolCallV1 {
+    type: 'tool_call';
+    callId: string;
+    tool: ToolId;
+    args: Record<string, unknown>;
+}
+export interface ToolResultErrorV1 {
+    message: string;
+    code?: string;
+    details?: unknown;
+}
+export interface ToolResultV1 {
+    type: 'tool_result';
+    callId: string;
+    tool: ToolId;
+    ok: boolean;
+    output?: unknown;
+    error?: ToolResultErrorV1;
+}
+export interface ToolSpecV1 {
+    id: ToolId;
+    description?: string;
+    jsonSchema?: unknown;
+}
+export declare function isToolCallV1(x: unknown): x is ToolCallV1;
+export declare function isToolResultV1(x: unknown): x is ToolResultV1;

package/dist/tools.js

@@ -0,0 +1,34 @@
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+export function isToolCallV1(x) {
+    if (!isPlainObject(x))
+        return false;
+    return (x.type === 'tool_call' &&
+        typeof x.callId === 'string' &&
+        x.callId.trim().length > 0 &&
+        typeof x.tool === 'string' &&
+        x.tool.trim().length > 0 &&
+        isPlainObject(x.args));
+}
+export function isToolResultV1(x) {
+    if (!isPlainObject(x))
+        return false;
+    if (x.type !== 'tool_result' ||
+        typeof x.callId !== 'string' ||
+        x.callId.trim().length === 0 ||
+        typeof x.tool !== 'string' ||
+        x.tool.trim().length === 0 ||
+        typeof x.ok !== 'boolean') {
+        return false;
+    }
+    if (x.ok) {
+        return x.error === undefined;
+    }
+    return (isPlainObject(x.error) &&
+        typeof x.error.message === 'string' &&
+        x.error.message.trim().length > 0);
+}