@botbotgo/agent-harness 0.0.475 → 0.0.476

package/dist/runtime/harness/system/store.js

@@ -1,219 +1,4 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { mkdirSync } from "node:fs";
-import path from "node:path";
-import { InMemoryStore } from "@langchain/langgraph";
-import { createClient } from "@libsql/client";
-const NAMESPACE_SEPARATOR = "\u001f";
-function encodeValue(value) {
-    if (value instanceof Date) {
-        return {
-            __type: "Date",
-            value: value.toISOString(),
-        };
-    }
-    if (value instanceof Uint8Array) {
-        return {
-            __type: "Uint8Array",
-            data: Array.from(value),
-        };
-    }
-    if (value instanceof Map) {
-        return {
-            __type: "Map",
-            entries: Array.from(value.entries()).map(([key, entry]) => [encodeValue(key), encodeValue(entry)]),
-        };
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => encodeValue(item));
-    }
-    if (typeof value === "object" && value) {
-        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, encodeValue(entry)]));
-    }
-    return value;
-}
-function decodeValue(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => decodeValue(item));
-    }
-    if (typeof value === "object" && value) {
-        const typed = value;
-        if (typed.__type === "Date" && typeof typed.value === "string") {
-            return new Date(typed.value);
-        }
-        if (typed.__type === "Uint8Array" && Array.isArray(typed.data)) {
-            return new Uint8Array(typed.data.map((item) => Number(item)));
-        }
-        if (typed.__type === "Map" && Array.isArray(typed.entries)) {
-            return new Map(typed.entries.map((entry) => {
-                const [key, item] = Array.isArray(entry) ? entry : [undefined, undefined];
-                return [decodeValue(key), decodeValue(item)];
-            }));
-        }
-        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, decodeValue(entry)]));
-    }
-    return value;
-}
-function serializeNamespace(namespace) {
-    return namespace.join(NAMESPACE_SEPARATOR);
-}
-function parseRow(row) {
-    return {
-        value: decodeValue(JSON.parse(row.value_json)),
-        key: row.key,
-        namespace: JSON.parse(row.namespace_json),
-        createdAt: new Date(row.created_at),
-        updatedAt: new Date(row.updated_at),
-    };
-}
-function isKnowledgeRecordNamespace(namespace) {
-    return namespace.length === 3 && namespace[0] === "memories" && namespace[1] === "records";
-}
-function extractKnowledgeRecordEntry(namespace, key, value, createdAt, updatedAt) {
-    if (!isKnowledgeRecordNamespace(namespace) || typeof value !== "object" || value === null || Array.isArray(value)) {
-        return null;
-    }
-    const typed = value;
-    const recordId = typeof typed.id === "string" ? typed.id : undefined;
-    const scope = typeof typed.scope === "string" ? typed.scope : undefined;
-    const kind = typeof typed.kind === "string" ? typed.kind : undefined;
-    const status = typeof typed.status === "string" ? typed.status : undefined;
-    const canonicalKey = typeof typed.canonicalKey === "string" ? typed.canonicalKey : undefined;
-    const sourceType = typeof typed.sourceType === "string" ? typed.sourceType : undefined;
-    const summary = typeof typed.summary === "string" ? typed.summary : undefined;
-    const content = typeof typed.content === "string" ? typed.content : undefined;
-    if (!recordId || !scope || !kind || !status || !canonicalKey || !sourceType || !summary || !content) {
-        return null;
-    }
-    return {
-        namespace: serializeNamespace(namespace),
-        key,
-        record_id: recordId,
-        scope,
-        kind,
-        status,
-        canonical_key: canonicalKey,
-        source_type: sourceType,
-        knowledge_identity: typeof typed.knowledgeIdentity === "string" ? typed.knowledgeIdentity : null,
-        knowledge_operation: typeof typed.knowledgeOperation === "string" ? typed.knowledgeOperation : null,
-        summary_text: summary,
-        content_text: content,
-        confidence: typeof typed.confidence === "number" ? typed.confidence : null,
-        observed_at: typeof typed.observedAt === "string" ? typed.observedAt : null,
-        last_confirmed_at: typeof typed.lastConfirmedAt === "string" ? typed.lastConfirmedAt : null,
-        created_at: createdAt,
-        updated_at: updatedAt,
-    };
-}
-export class FileBackedStore {
-    filePath;
-    delegate = new InMemoryStore();
-    loaded = false;
-    operationChain = Promise.resolve();
-    constructor(filePath) {
-        this.filePath = filePath;
-    }
-    async runSerialized(operation) {
-        const pending = this.operationChain.then(operation, operation);
-        this.operationChain = pending.then(() => undefined, () => undefined);
-        return pending;
-    }
-    async ensureLoaded() {
-        if (this.loaded) {
-            return;
-        }
-        try {
-            const raw = await readFile(this.filePath, "utf8");
-            const parsed = JSON.parse(raw);
-            this.delegate.data = decodeValue(parsed.data);
-            this.delegate.vectors = decodeValue(parsed.vectors);
-        }
-        catch {
-            this.delegate.data = new Map();
-            this.delegate.vectors = new Map();
-        }
-        this.loaded = true;
-    }
-    async persist() {
-        await mkdir(path.dirname(this.filePath), { recursive: true });
-        await writeFile(this.filePath, JSON.stringify({
-            data: encodeValue(this.delegate.data),
-            vectors: encodeValue(this.delegate.vectors),
-        }, null, 2), "utf8");
-    }
-    async batch(operations) {
-        return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            const result = await this.delegate.batch(operations);
-            if (operations.some((operation) => "value" in operation)) {
-                await this.persist();
-            }
-            return result;
-        });
-    }
-    async get(namespace, key) {
-        return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            return this.delegate.get(namespace, key);
-        });
-    }
-    async search(namespacePrefix, options) {
-        return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            return this.delegate.search(namespacePrefix, options);
-        });
-    }
-    async put(namespace, key, value, index) {
-        return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            const result = await this.delegate.put(namespace, key, value, index);
-            await this.persist();
-            return result;
-        });
-    }
-    async delete(namespace, key) {
-        return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            const result = await this.delegate.delete(namespace, key);
-            await this.persist();
-            return result;
-        });
-    }
-    async listNamespaces(options) {
-        return this.runSerialized(async () => {
-            await this.ensureLoaded();
-            return this.delegate.listNamespaces(options);
-        });
-    }
-}
-export class SqliteBackedStore {
-    filePath;
-    client = null;
-    initialized = false;
-    initialization = null;
-    constructor(filePath) {
-        this.filePath = filePath;
-        mkdirSync(path.dirname(filePath), { recursive: true });
-    }
-    async getClient() {
-        if (!this.client) {
-            this.client = createClient({ url: `file:${this.filePath}` });
-        }
-        return this.client;
-    }
-    async ensureInitialized() {
-        if (this.initialized) {
-            return;
-        }
-        if (this.initialization) {
-            await this.initialization;
-            return;
-        }
-        this.initialization = (async () => {
-            const client = await this.getClient();
-            await client.execute("PRAGMA journal_mode=WAL");
-            await client.execute("PRAGMA foreign_keys=ON");
-            await client.execute("PRAGMA busy_timeout=5000");
-            await client.execute(`
+import{mkdir as N,readFile as k,writeFile as A}from"node:fs/promises";import{mkdirSync as O}from"node:fs";import E from"node:path";import{InMemoryStore as m}from"@langchain/langgraph";import{createClient as L}from"@libsql/client";const p="";function c(a){return a instanceof Date?{__type:"Date",value:a.toISOString()}:a instanceof Uint8Array?{__type:"Uint8Array",data:Array.from(a)}:a instanceof Map?{__type:"Map",entries:Array.from(a.entries()).map(([e,t])=>[c(e),c(t)])}:Array.isArray(a)?a.map(e=>c(e)):typeof a=="object"&&a?Object.fromEntries(Object.entries(a).map(([e,t])=>[e,c(t)])):a}function o(a){if(Array.isArray(a))return a.map(e=>o(e));if(typeof a=="object"&&a){const e=a;return e.__type==="Date"&&typeof e.value=="string"?new Date(e.value):e.__type==="Uint8Array"&&Array.isArray(e.data)?new Uint8Array(e.data.map(t=>Number(t))):e.__type==="Map"&&Array.isArray(e.entries)?new Map(e.entries.map(t=>{const[i,s]=Array.isArray(t)?t:[void 0,void 0];return[o(i),o(s)]})):Object.fromEntries(Object.entries(a).map(([t,i])=>[t,o(i)]))}return a}function l(a){return a.join(p)}function g(a){return{value:o(JSON.parse(a.value_json)),key:a.key,namespace:JSON.parse(a.namespace_json),createdAt:new Date(a.created_at),updatedAt:new Date(a.updated_at)}}function x(a){return a.length===3&&a[0]==="memories"&&a[1]==="records"}function h(a,e,t,i,s){if(!x(a)||typeof t!="object"||t===null||Array.isArray(t))return null;const n=t,r=typeof n.id=="string"?n.id:void 0,d=typeof n.scope=="string"?n.scope:void 0,_=typeof n.kind=="string"?n.kind:void 0,u=typeof n.status=="string"?n.status:void 0,y=typeof n.canonicalKey=="string"?n.canonicalKey:void 0,w=typeof n.sourceType=="string"?n.sourceType:void 0,f=typeof n.summary=="string"?n.summary:void 0,T=typeof n.content=="string"?n.content:void 0;return!r||!d||!_||!u||!y||!w||!f||!T?null:{namespace:l(a),key:e,record_id:r,scope:d,kind:_,status:u,canonical_key:y,source_type:w,knowledge_identity:typeof n.knowledgeIdentity=="string"?n.knowledgeIdentity:null,knowledge_operation:typeof n.knowledgeOperation=="string"?n.knowledgeOperation:null,summary_text:f,content_text:T,confidence:typeof n.confidence=="number"?n.confidence:null,observed_at:typeof n.observedAt=="string"?n.observedAt:null,last_confirmed_at:typeof n.lastConfirmedAt=="string"?n.lastConfirmedAt:null,created_at:i,updated_at:s}}class j{filePath;delegate=new m;loaded=!1;operationChain=Promise.resolve();constructor(e){this.filePath=e}async runSerialized(e){const t=this.operationChain.then(e,e);return this.operationChain=t.then(()=>{},()=>{}),t}async ensureLoaded(){if(!this.loaded){try{const e=await k(this.filePath,"utf8"),t=JSON.parse(e);this.delegate.data=o(t.data),this.delegate.vectors=o(t.vectors)}catch{this.delegate.data=new Map,this.delegate.vectors=new Map}this.loaded=!0}}async persist(){await N(E.dirname(this.filePath),{recursive:!0}),await A(this.filePath,JSON.stringify({data:c(this.delegate.data),vectors:c(this.delegate.vectors)},null,2),"utf8")}async batch(e){return this.runSerialized(async()=>{await this.ensureLoaded();const t=await this.delegate.batch(e);return e.some(i=>"value"in i)&&await this.persist(),t})}async get(e,t){return this.runSerialized(async()=>(await this.ensureLoaded(),this.delegate.get(e,t)))}async search(e,t){return this.runSerialized(async()=>(await this.ensureLoaded(),this.delegate.search(e,t)))}async put(e,t,i,s){return this.runSerialized(async()=>{await this.ensureLoaded();const n=await this.delegate.put(e,t,i,s);return await this.persist(),n})}async delete(e,t){return this.runSerialized(async()=>{await this.ensureLoaded();const i=await this.delegate.delete(e,t);return await this.persist(),i})}async listNamespaces(e){return this.runSerialized(async()=>(await this.ensureLoaded(),this.delegate.listNamespaces(e)))}}class U{filePath;client=null;initialized=!1;initialization=null;constructor(e){this.filePath=e,O(E.dirname(e),{recursive:!0})}async getClient(){return this.client||(this.client=L({url:`file:${this.filePath}`})),this.client}async ensureInitialized(){if(!this.initialized){if(this.initialization){await this.initialization;return}this.initialization=(async()=>{const e=await this.getClient();await e.execute("PRAGMA journal_mode=WAL"),await e.execute("PRAGMA foreign_keys=ON"),await e.execute("PRAGMA busy_timeout=5000"),await e.execute(`
         CREATE TABLE IF NOT EXISTS store_entries (
           namespace TEXT NOT NULL,
           namespace_json TEXT NOT NULL,
@@ -223,9 +8,7 @@ export class SqliteBackedStore {
           updated_at TEXT NOT NULL,
           PRIMARY KEY (namespace, key)
         )
-      `);
-            await client.execute("CREATE INDEX IF NOT EXISTS idx_store_entries_namespace ON store_entries(namespace)");
-            await client.execute(`
+      `),await e.execute("CREATE INDEX IF NOT EXISTS idx_store_entries_namespace ON store_entries(namespace)"),await e.execute(`
         CREATE TABLE IF NOT EXISTS knowledge_record_entries (
           namespace TEXT NOT NULL,
           key TEXT NOT NULL,
@@ -246,51 +29,9 @@ export class SqliteBackedStore {
           updated_at TEXT NOT NULL,
           PRIMARY KEY (namespace, key)
         )
-      `);
-            await this.ensureKnowledgeRecordEntryColumns(client);
-            await client.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_scope_status ON knowledge_record_entries(scope, status)");
-            await client.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_canonical_key ON knowledge_record_entries(canonical_key)");
-            await client.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_knowledge_identity ON knowledge_record_entries(knowledge_identity)");
-            await client.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_record_id ON knowledge_record_entries(record_id)");
-            await this.backfillKnowledgeRecordEntries(client);
-            this.initialized = true;
-            this.initialization = null;
-        })();
-        await this.initialization;
-    }
-    async ensureKnowledgeRecordEntryColumns(client) {
-        const result = await client.execute("PRAGMA table_info(knowledge_record_entries)");
-        const existing = new Set(result.rows.map((row) => String(row.name ?? "")));
-        if (!existing.has("knowledge_identity")) {
-            await client.execute("ALTER TABLE knowledge_record_entries ADD COLUMN knowledge_identity TEXT");
-        }
-        if (!existing.has("knowledge_operation")) {
-            await client.execute("ALTER TABLE knowledge_record_entries ADD COLUMN knowledge_operation TEXT");
-        }
-    }
-    async backfillKnowledgeRecordEntries(client) {
-        const countResult = await client.execute("SELECT COUNT(*) AS count FROM knowledge_record_entries");
-        const count = Number(countResult.rows?.[0]?.count ?? 0);
-        if (count > 0) {
-            return;
-        }
-        const result = await client.execute({
-            sql: `SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+      `),await this.ensureKnowledgeRecordEntryColumns(e),await e.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_scope_status ON knowledge_record_entries(scope, status)"),await e.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_canonical_key ON knowledge_record_entries(canonical_key)"),await e.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_knowledge_identity ON knowledge_record_entries(knowledge_identity)"),await e.execute("CREATE INDEX IF NOT EXISTS idx_knowledge_record_entries_record_id ON knowledge_record_entries(record_id)"),await this.backfillKnowledgeRecordEntries(e),this.initialized=!0,this.initialization=null})(),await this.initialization}}async ensureKnowledgeRecordEntryColumns(e){const t=await e.execute("PRAGMA table_info(knowledge_record_entries)"),i=new Set(t.rows.map(s=>String(s.name??"")));i.has("knowledge_identity")||await e.execute("ALTER TABLE knowledge_record_entries ADD COLUMN knowledge_identity TEXT"),i.has("knowledge_operation")||await e.execute("ALTER TABLE knowledge_record_entries ADD COLUMN knowledge_operation TEXT")}async backfillKnowledgeRecordEntries(e){const t=await e.execute("SELECT COUNT(*) AS count FROM knowledge_record_entries");if(Number(t.rows?.[0]?.count??0)>0)return;const s=await e.execute({sql:`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
             FROM store_entries
-            WHERE namespace LIKE ?`,
-            args: [`memories${NAMESPACE_SEPARATOR}records${NAMESPACE_SEPARATOR}%`],
-        });
-        for (const row of result.rows) {
-            const namespace = JSON.parse(row.namespace_json);
-            const entry = extractKnowledgeRecordEntry(namespace, row.key, decodeValue(JSON.parse(row.value_json)), row.created_at, row.updated_at);
-            if (entry) {
-                await this.upsertKnowledgeRecordEntry(client, entry);
-            }
-        }
-    }
-    async upsertKnowledgeRecordEntry(client, entry) {
-        await client.execute({
-            sql: `INSERT INTO knowledge_record_entries (
+            WHERE namespace LIKE ?`,args:[`memories${p}records${p}%`]});for(const n of s.rows){const r=JSON.parse(n.namespace_json),d=h(r,n.key,o(JSON.parse(n.value_json)),n.created_at,n.updated_at);d&&await this.upsertKnowledgeRecordEntry(e,d)}}async upsertKnowledgeRecordEntry(e,t){await e.execute({sql:`INSERT INTO knowledge_record_entries (
          namespace, key, record_id, scope, kind, status, canonical_key, source_type,
          knowledge_identity, knowledge_operation, summary_text, content_text, confidence, observed_at, last_confirmed_at, created_at, updated_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -308,113 +49,16 @@ export class SqliteBackedStore {
          confidence = excluded.confidence,
          observed_at = excluded.observed_at,
          last_confirmed_at = excluded.last_confirmed_at,
-         updated_at = excluded.updated_at`,
-            args: [
-                entry.namespace,
-                entry.key,
-                entry.record_id,
-                entry.scope,
-                entry.kind,
-                entry.status,
-                entry.canonical_key,
-                entry.source_type,
-                entry.knowledge_identity,
-                entry.knowledge_operation,
-                entry.summary_text,
-                entry.content_text,
-                entry.confidence,
-                entry.observed_at,
-                entry.last_confirmed_at,
-                entry.created_at,
-                entry.updated_at,
-            ],
-        });
-    }
-    async deleteKnowledgeRecordEntry(client, namespace, key) {
-        await client.execute({
-            sql: `DELETE FROM knowledge_record_entries WHERE namespace = ? AND key = ?`,
-            args: [serializeNamespace(namespace), key],
-        });
-    }
-    async selectAll(sql, args = []) {
-        await this.ensureInitialized();
-        const client = await this.getClient();
-        const result = await client.execute({ sql, args });
-        return result.rows;
-    }
-    async batch(operations) {
-        const results = [];
-        for (const operation of operations) {
-            const namespace = Array.isArray(operation.namespace) ? operation.namespace.filter((item) => typeof item === "string") : [];
-            const key = typeof operation.key === "string" ? operation.key : "";
-            if ("value" in operation) {
-                await this.put(namespace, key, operation.value);
-                results.push(undefined);
-                continue;
-            }
-            if (operation.delete === true) {
-                await this.delete(namespace, key);
-                results.push(undefined);
-                continue;
-            }
-            results.push(await this.get(namespace, key));
-        }
-        return results;
-    }
-    async get(namespace, key) {
-        const rows = await this.selectAll(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+         updated_at = excluded.updated_at`,args:[t.namespace,t.key,t.record_id,t.scope,t.kind,t.status,t.canonical_key,t.source_type,t.knowledge_identity,t.knowledge_operation,t.summary_text,t.content_text,t.confidence,t.observed_at,t.last_confirmed_at,t.created_at,t.updated_at]})}async deleteKnowledgeRecordEntry(e,t,i){await e.execute({sql:"DELETE FROM knowledge_record_entries WHERE namespace = ? AND key = ?",args:[l(t),i]})}async selectAll(e,t=[]){return await this.ensureInitialized(),(await(await this.getClient()).execute({sql:e,args:t})).rows}async batch(e){const t=[];for(const i of e){const s=Array.isArray(i.namespace)?i.namespace.filter(r=>typeof r=="string"):[],n=typeof i.key=="string"?i.key:"";if("value"in i){await this.put(s,n,i.value),t.push(void 0);continue}if(i.delete===!0){await this.delete(s,n),t.push(void 0);continue}t.push(await this.get(s,n))}return t}async get(e,t){const s=(await this.selectAll(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
        FROM store_entries
-       WHERE namespace = ? AND key = ?`, [serializeNamespace(namespace), key]);
-        const row = rows[0];
-        return row ? parseRow(row) : null;
-    }
-    async search(namespacePrefix) {
-        const prefix = serializeNamespace(namespacePrefix);
-        const rows = await this.selectAll(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+       WHERE namespace = ? AND key = ?`,[l(e),t]))[0];return s?g(s):null}async search(e){const t=l(e);return(await this.selectAll(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
        FROM store_entries
        WHERE namespace = ? OR namespace LIKE ?
-       ORDER BY namespace ASC, key ASC`, [prefix, `${prefix}${NAMESPACE_SEPARATOR}%`]);
-        return rows.map((row) => parseRow(row));
-    }
-    async put(namespace, key, value, _index) {
-        await this.ensureInitialized();
-        const client = await this.getClient();
-        const now = new Date().toISOString();
-        const serializedNamespace = serializeNamespace(namespace);
-        const encodedValue = JSON.stringify(encodeValue(value));
-        await client.execute({
-            sql: `INSERT INTO store_entries (namespace, namespace_json, key, value_json, created_at, updated_at)
+       ORDER BY namespace ASC, key ASC`,[t,`${t}${p}%`])).map(s=>g(s))}async put(e,t,i,s){await this.ensureInitialized();const n=await this.getClient(),r=new Date().toISOString(),d=l(e),_=JSON.stringify(c(i));await n.execute({sql:`INSERT INTO store_entries (namespace, namespace_json, key, value_json, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT(namespace, key) DO UPDATE SET
          namespace_json = excluded.namespace_json,
          value_json = excluded.value_json,
-         updated_at = excluded.updated_at`,
-            args: [serializedNamespace, JSON.stringify(namespace), key, encodedValue, now, now],
-        });
-        const knowledgeEntry = extractKnowledgeRecordEntry(namespace, key, value, now, now);
-        if (knowledgeEntry) {
-            await this.upsertKnowledgeRecordEntry(client, knowledgeEntry);
-        }
-        else {
-            await this.deleteKnowledgeRecordEntry(client, namespace, key);
-        }
-    }
-    async delete(namespace, key) {
-        await this.ensureInitialized();
-        const client = await this.getClient();
-        await client.execute({
-            sql: `DELETE FROM store_entries WHERE namespace = ? AND key = ?`,
-            args: [serializeNamespace(namespace), key],
-        });
-        await this.deleteKnowledgeRecordEntry(client, namespace, key);
-    }
-    async listNamespaces() {
-        const rows = await this.selectAll(`SELECT DISTINCT namespace_json
+         updated_at = excluded.updated_at`,args:[d,JSON.stringify(e),t,_,r,r]});const u=h(e,t,i,r,r);u?await this.upsertKnowledgeRecordEntry(n,u):await this.deleteKnowledgeRecordEntry(n,e,t)}async delete(e,t){await this.ensureInitialized();const i=await this.getClient();await i.execute({sql:"DELETE FROM store_entries WHERE namespace = ? AND key = ?",args:[l(e),t]}),await this.deleteKnowledgeRecordEntry(i,e,t)}async listNamespaces(){return(await this.selectAll(`SELECT DISTINCT namespace_json
        FROM store_entries
-       ORDER BY namespace ASC`);
-        return rows.map((row) => JSON.parse(row.namespace_json));
-    }
-}
-export function createInMemoryStore() {
-    return new InMemoryStore();
-}
+       ORDER BY namespace ASC`)).map(t=>JSON.parse(t.namespace_json))}}function D(){return new m}export{j as FileBackedStore,U as SqliteBackedStore,D as createInMemoryStore};

package/dist/runtime/harness/tool-gateway/index.js

@@ -1,2 +1 @@
-export * from "./policy.js";
-export * from "./validation.js";
+export*from"./policy.js";export*from"./validation.js";

package/dist/runtime/harness/tool-gateway/policy.js

@@ -1,45 +1 @@
-import { toolRequiresRuntimeApproval } from "../../adapter/tool/tool-hitl.js";
-import { getBindingPrimaryTools } from "../../support/compiled-binding.js";
-import { compiledToolHasInputSchema } from "../tool-schema.js";
-export function projectBindingToolGatewayPolicy(binding) {
-    const tools = getBindingPrimaryTools(binding).map((tool) => {
-        const hasInputSchema = compiledToolHasInputSchema(tool);
-        const requiresApproval = toolRequiresRuntimeApproval(tool);
-        return {
-            toolId: tool.id,
-            name: tool.name,
-            retryable: tool.retryable === true,
-            hasInputSchema,
-            requiresApproval,
-            gatewayMode: requiresApproval ? "approval-gated" : hasInputSchema ? "schema-first" : "best-effort",
-            modelRole: "propose",
-            runtimeRole: requiresApproval
-                ? "request-approval"
-                : hasInputSchema
-                    ? "validate-and-execute"
-                    : "execute-with-runtime-checks",
-        };
-    });
-    const schemaBoundToolCount = tools.filter((tool) => tool.hasInputSchema).length;
-    const approvalRequiredToolCount = tools.filter((tool) => tool.requiresApproval).length;
-    return {
-        layer: "tool-gateway",
-        toolScope: {
-            source: "agent-binding",
-            exposedToolCount: tools.length,
-            schemaBoundToolCount,
-            approvalRequiredToolCount,
-        },
-        validation: {
-            strategy: "schema-first",
-            runtimeValidationRequired: tools.some((tool) => !tool.hasInputSchema || tool.requiresApproval),
-            strictProviderSchemaPreferred: tools.length > 0,
-        },
-        correction: {
-            invalidArguments: "structured-error-retry",
-            maxModelRetries: 2,
-            highRiskInvalidArguments: "approval-or-deny",
-        },
-        tools,
-    };
-}
+import{toolRequiresRuntimeApproval as l}from"../../adapter/tool/tool-hitl.js";import{getBindingPrimaryTools as s}from"../../support/compiled-binding.js";import{compiledToolHasInputSchema as p}from"../tool-schema.js";function d(a){const r=s(a).map(e=>{const t=p(e),o=l(e);return{toolId:e.id,name:e.name,retryable:e.retryable===!0,hasInputSchema:t,requiresApproval:o,gatewayMode:o?"approval-gated":t?"schema-first":"best-effort",modelRole:"propose",runtimeRole:o?"request-approval":t?"validate-and-execute":"execute-with-runtime-checks"}}),i=r.filter(e=>e.hasInputSchema).length,n=r.filter(e=>e.requiresApproval).length;return{layer:"tool-gateway",toolScope:{source:"agent-binding",exposedToolCount:r.length,schemaBoundToolCount:i,approvalRequiredToolCount:n},validation:{strategy:"schema-first",runtimeValidationRequired:r.some(e=>!e.hasInputSchema||e.requiresApproval),strictProviderSchemaPreferred:r.length>0},correction:{invalidArguments:"structured-error-retry",maxModelRetries:2,highRiskInvalidArguments:"approval-or-deny"},tools:r}}export{d as projectBindingToolGatewayPolicy};

package/dist/runtime/harness/tool-gateway/validation.js

@@ -1,176 +1 @@
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readJsonSchemaType(schema) {
-    if (!isRecord(schema)) {
-        return [];
-    }
-    const type = schema.type;
-    if (typeof type === "string") {
-        return [type];
-    }
-    return Array.isArray(type) ? type.filter((entry) => typeof entry === "string") : [];
-}
-function typeMatches(value, allowedTypes) {
-    if (allowedTypes.length === 0) {
-        return true;
-    }
-    if (value === null) {
-        return allowedTypes.includes("null");
-    }
-    return allowedTypes.some((type) => {
-        if (type === "integer") {
-            return Number.isInteger(value);
-        }
-        if (type === "array") {
-            return Array.isArray(value);
-        }
-        if (type === "object") {
-            return isRecord(value);
-        }
-        return typeof value === type;
-    });
-}
-function toPath(path) {
-    if (path.length === 0) {
-        return "$";
-    }
-    let rendered = "$";
-    for (const part of path) {
-        rendered = typeof part === "number" ? `${rendered}[${part}]` : `${rendered}.${part}`;
-    }
-    return rendered;
-}
-function zodIssues(error) {
-    const issues = isRecord(error) && Array.isArray(error.issues) ? error.issues : [];
-    return issues
-        .map((issue) => {
-        if (!isRecord(issue)) {
-            return null;
-        }
-        const path = Array.isArray(issue.path) ? issue.path.filter((part) => typeof part === "string" || typeof part === "number") : [];
-        const message = typeof issue.message === "string" ? issue.message : "Invalid value";
-        return {
-            path: toPath(path),
-            message,
-            ...(typeof issue.expected === "string" ? { expected: issue.expected } : {}),
-            ...(typeof issue.received === "string" ? { received: issue.received } : {}),
-        };
-    })
-        .filter((issue) => issue !== null);
-}
-function validateJsonSchemaObject(schema, input) {
-    const issues = [];
-    const rootTypes = readJsonSchemaType(schema);
-    if (!typeMatches(input, rootTypes.length > 0 ? rootTypes : ["object"])) {
-        return [{
-                path: "$",
-                message: "Tool input must match the declared schema root type.",
-                expected: rootTypes.join("|") || "object",
-                received: Array.isArray(input) ? "array" : input === null ? "null" : typeof input,
-            }];
-    }
-    if (!isRecord(input)) {
-        return issues;
-    }
-    const properties = isRecord(schema.properties) ? schema.properties : {};
-    const required = Array.isArray(schema.required)
-        ? schema.required.filter((entry) => typeof entry === "string")
-        : [];
-    for (const key of required) {
-        if (!(key in input)) {
-            issues.push({
-                path: `$.${key}`,
-                message: "Required tool argument is missing.",
-            });
-        }
-    }
-    for (const [key, value] of Object.entries(input)) {
-        const fieldSchema = properties[key];
-        if (!fieldSchema) {
-            if (schema.additionalProperties === false) {
-                issues.push({
-                    path: `$.${key}`,
-                    message: "Unexpected tool argument.",
-                });
-            }
-            continue;
-        }
-        const fieldTypes = readJsonSchemaType(fieldSchema);
-        if (!typeMatches(value, fieldTypes)) {
-            issues.push({
-                path: `$.${key}`,
-                message: "Tool argument has the wrong type.",
-                ...(fieldTypes.length > 0 ? { expected: fieldTypes.join("|") } : {}),
-                received: Array.isArray(value) ? "array" : value === null ? "null" : typeof value,
-            });
-        }
-        if (isRecord(fieldSchema) && Array.isArray(fieldSchema.enum) && !fieldSchema.enum.includes(value)) {
-            issues.push({
-                path: `$.${key}`,
-                message: "Tool argument must be one of the declared enum values.",
-            });
-        }
-    }
-    return issues;
-}
-export function createInvalidToolArgumentsResult(input) {
-    return {
-        isError: true,
-        code: "INVALID_ARGUMENTS",
-        toolName: input.toolName,
-        message: `Tool ${input.toolName} received invalid arguments. Correct the arguments to match the declared schema before retrying.`,
-        retryable: !input.requiresApproval,
-        requiresApproval: input.requiresApproval,
-        validationErrors: input.issues.length > 0
-            ? input.issues
-            : [{ path: "$", message: "Tool input failed schema validation." }],
-    };
-}
-export function validateToolGatewayInput(input) {
-    const schema = input.schema;
-    const requiresApproval = input.requiresApproval === true;
-    if (schema && typeof schema.safeParse === "function") {
-        const parsed = schema.safeParse(input.args);
-        if (parsed.success) {
-            return { ok: true, input: parsed.data };
-        }
-        return {
-            ok: false,
-            error: createInvalidToolArgumentsResult({
-                toolName: input.toolName,
-                requiresApproval,
-                issues: zodIssues(parsed.error),
-            }),
-        };
-    }
-    if (schema && typeof schema.parse === "function") {
-        try {
-            return { ok: true, input: schema.parse(input.args) };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: createInvalidToolArgumentsResult({
-                    toolName: input.toolName,
-                    requiresApproval,
-                    issues: zodIssues(error),
-                }),
-            };
-        }
-    }
-    if (isRecord(input.schema) && (input.schema.type === "object" || isRecord(input.schema.properties))) {
-        const issues = validateJsonSchemaObject(input.schema, input.args);
-        if (issues.length > 0) {
-            return {
-                ok: false,
-                error: createInvalidToolArgumentsResult({
-                    toolName: input.toolName,
-                    requiresApproval,
-                    issues,
-                }),
-            };
-        }
-    }
-    return { ok: true, input: input.args };
-}
+function a(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function p(e){if(!a(e))return[];const t=e.type;return typeof t=="string"?[t]:Array.isArray(t)?t.filter(r=>typeof r=="string"):[]}function y(e,t){return t.length===0?!0:e===null?t.includes("null"):t.some(r=>r==="integer"?Number.isInteger(e):r==="array"?Array.isArray(e):r==="object"?a(e):typeof e===r)}function d(e){if(e.length===0)return"$";let t="$";for(const r of e)t=typeof r=="number"?`${t}[${r}]`:`${t}.${r}`;return t}function m(e){return(a(e)&&Array.isArray(e.issues)?e.issues:[]).map(r=>{if(!a(r))return null;const o=Array.isArray(r.path)?r.path.filter(c=>typeof c=="string"||typeof c=="number"):[],f=typeof r.message=="string"?r.message:"Invalid value";return{path:d(o),message:f,...typeof r.expected=="string"?{expected:r.expected}:{},...typeof r.received=="string"?{received:r.received}:{}}}).filter(r=>r!==null)}function g(e,t){const r=[],o=p(e);if(!y(t,o.length>0?o:["object"]))return[{path:"$",message:"Tool input must match the declared schema root type.",expected:o.join("|")||"object",received:Array.isArray(t)?"array":t===null?"null":typeof t}];if(!a(t))return r;const f=a(e.properties)?e.properties:{},c=Array.isArray(e.required)?e.required.filter(s=>typeof s=="string"):[];for(const s of c)s in t||r.push({path:`$.${s}`,message:"Required tool argument is missing."});for(const[s,n]of Object.entries(t)){const i=f[s];if(!i){e.additionalProperties===!1&&r.push({path:`$.${s}`,message:"Unexpected tool argument."});continue}const l=p(i);y(n,l)||r.push({path:`$.${s}`,message:"Tool argument has the wrong type.",...l.length>0?{expected:l.join("|")}:{},received:Array.isArray(n)?"array":n===null?"null":typeof n}),a(i)&&Array.isArray(i.enum)&&!i.enum.includes(n)&&r.push({path:`$.${s}`,message:"Tool argument must be one of the declared enum values."})}return r}function u(e){return{isError:!0,code:"INVALID_ARGUMENTS",toolName:e.toolName,message:`Tool ${e.toolName} received invalid arguments. Correct the arguments to match the declared schema before retrying.`,retryable:!e.requiresApproval,requiresApproval:e.requiresApproval,validationErrors:e.issues.length>0?e.issues:[{path:"$",message:"Tool input failed schema validation."}]}}function h(e){const t=e.schema,r=e.requiresApproval===!0;if(t&&typeof t.safeParse=="function"){const o=t.safeParse(e.args);return o.success?{ok:!0,input:o.data}:{ok:!1,error:u({toolName:e.toolName,requiresApproval:r,issues:m(o.error)})}}if(t&&typeof t.parse=="function")try{return{ok:!0,input:t.parse(e.args)}}catch(o){return{ok:!1,error:u({toolName:e.toolName,requiresApproval:r,issues:m(o)})}}if(a(e.schema)&&(e.schema.type==="object"||a(e.schema.properties))){const o=g(e.schema,e.args);if(o.length>0)return{ok:!1,error:u({toolName:e.toolName,requiresApproval:r,issues:o})}}return{ok:!0,input:e.args}}export{u as createInvalidToolArgumentsResult,h as validateToolGatewayInput};

package/dist/runtime/harness/tool-schema.js

@@ -1,3 +1 @@
-export function compiledToolHasInputSchema(tool) {
-    return (typeof tool.inputSchemaRef === "string" && tool.inputSchemaRef.trim().length > 0) || tool.hasModuleSchema === true;
-}
+function t(e){return typeof e.inputSchemaRef=="string"&&e.inputSchemaRef.trim().length>0||e.hasModuleSchema===!0}export{t as compiledToolHasInputSchema};