stable-harness 0.0.37 → 0.0.39

package/node_modules/@stable-harness/memory/dist/src/policy.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryPolicy } from "./types.js";
+export declare function createDefaultMemoryPolicy(): MemoryPolicy;

package/node_modules/@stable-harness/memory/dist/src/policy.js

@@ -0,0 +1 @@
+export function createDefaultMemoryPolicy(){return{decide:e=>e.noStore?{action:"reject",reason:"candidate marked noStore",reviewRequired:!1}:e.content.trim()?"sensitive"===e.sensitivity||"restricted"===e.sensitivity?{action:"review",reason:"sensitive memory requires operator approval",kind:e.kindHint??"semantic",scope:e.scopeHint??"workspace",confidence:normalizeConfidence(e.confidenceHint),reviewRequired:!0}:{action:"store",reason:"candidate accepted by default runtime policy",kind:e.kindHint??"semantic",scope:e.scopeHint??"workspace",confidence:normalizeConfidence(e.confidenceHint),retrievalPriority:0,reviewRequired:!1}:{action:"reject",reason:"candidate content is empty",reviewRequired:!1}}}function normalizeConfidence(e){return void 0===e||Number.isNaN(e)?.6:Math.min(1,Math.max(0,e))}

package/node_modules/@stable-harness/memory/dist/src/provider.d.ts

@@ -0,0 +1,50 @@
+import type { MemoryCandidate, MemoryKind, MemoryMaintenanceOperation, MemoryRecord, MemoryScope, MemorySensitivity, RuntimeMemoryStore } from "./types.js";
+export type MemoryProviderMode = {
+    hotPathTools?: boolean;
+    backgroundManager?: boolean;
+};
+export type MemoryProviderTypeConfig = Partial<Record<MemoryKind, boolean>>;
+export type MemoryProviderApprovalConfig = {
+    procedural?: boolean;
+    sensitive?: boolean;
+    restricted?: boolean;
+};
+export type MemoryProviderDefaults = {
+    scope?: MemoryScope;
+    sensitivity?: MemorySensitivity;
+};
+export type MemoryProviderConfig = {
+    provider?: "embedded" | "langmem-service" | "custom";
+    mode?: MemoryProviderMode;
+    types?: MemoryProviderTypeConfig;
+    approval?: MemoryProviderApprovalConfig;
+    defaults?: MemoryProviderDefaults;
+};
+export type MemoryProviderProposeInput = {
+    namespace: string;
+    content: string;
+    sourceType?: string;
+    sourceRef?: string;
+    kindHint?: MemoryKind;
+    scopeHint?: MemoryScope;
+    sensitivity?: MemorySensitivity;
+    metadata?: Record<string, unknown>;
+};
+export type MemoryProviderSearchInput = {
+    store?: RuntimeMemoryStore;
+    namespace: string;
+    query: string;
+    limit?: number;
+    kinds?: MemoryKind[];
+};
+export type MemoryProviderConsolidateInput = {
+    records: MemoryRecord[];
+};
+export type MemoryProvider = {
+    name: string;
+    config: MemoryProviderConfig;
+    propose(input: MemoryProviderProposeInput): Promise<MemoryCandidate[]>;
+    search(input: MemoryProviderSearchInput): Promise<MemoryRecord[]>;
+    consolidate(input: MemoryProviderConsolidateInput): Promise<MemoryMaintenanceOperation[]>;
+};
+export declare function createEmbeddedMemoryProvider(config?: MemoryProviderConfig): MemoryProvider;

package/node_modules/@stable-harness/memory/dist/src/provider.js

@@ -0,0 +1 @@
+export function createEmbeddedMemoryProvider(e={}){return{name:"embedded",config:e,async propose(n){const s=n.kindHint??function inferKind(e){const n=e.toLowerCase();return n.includes("must ")||n.includes("should ")?"procedural":n.includes("run ")||n.includes("failed ")?"episodic":"semantic"}(n.content);return function isKindEnabled(e,n){return!1!==e.types?.[n]}(e,s)?[{namespace:n.namespace,content:n.content,sourceType:n.sourceType,sourceRef:n.sourceRef,kindHint:s,scopeHint:n.scopeHint??e.defaults?.scope??"workspace",sensitivity:n.sensitivity??e.defaults?.sensitivity??"internal",confidenceHint:.6,metadata:n.metadata}]:[]},search:async e=>e.store?(await e.store.recall({namespace:e.namespace,query:e.query,limit:e.limit,kinds:e.kinds})).records:[],consolidate:async e=>e.records.filter(e=>"stale"===e.status).map(e=>({action:"archive",recordId:e.id,reason:"embedded provider archives stale records during consolidation"}))}}

package/node_modules/@stable-harness/memory/dist/src/store.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryPolicy, MemoryRecord, RuntimeMemoryStore } from "./types.js";
+export declare function createInMemoryRuntimeMemoryStore(options?: {
+    policy?: MemoryPolicy;
+    records?: MemoryRecord[];
+}): RuntimeMemoryStore;

package/node_modules/@stable-harness/memory/dist/src/store.js

@@ -0,0 +1 @@
+import{randomUUID as e}from"node:crypto";import{createDefaultMemoryPolicy as t}from"./policy.js";import{cloneRecords as n}from"./persistence.js";export function createInMemoryRuntimeMemoryStore(e={}){const r=e.policy??t(),o=n(e.records??[]);return{async submitCandidate(e){const t=r.decide(e);if("store"!==t.action)return{candidate:e,decision:t};const n=createRecord({namespace:e.namespace,content:e.content,kind:t.kind,scope:t.scope,summary:e.summary,confidence:t.confidence,tags:e.tags,sensitivity:e.sensitivity,sourceType:e.sourceType,sourceRef:e.sourceRef,metadata:e.metadata,provenance:e.provenance,observedAt:e.observedAt,retrievalPriority:t.retrievalPriority});return o.push(n),{candidate:e,decision:{...t,recordId:n.id},record:cloneRecord(n)}},async memorize(e){const t=createRecord(e);return o.push(t),cloneRecord(t)},async recall(e){const t=e.query.toLowerCase(),n=filterRecords(o,e).filter(e=>function matchesQuery(e,t){return[e.canonicalKey,e.content,e.summary??"",...e.tags].join("\n").toLowerCase().includes(t)}(e,t)).sort(compareRecallPriority).slice(0,e.limit??10);return{records:n,context:buildMemoryContext(n)}},list:async e=>n(filterRecords(o,e)),async update(e){const t=o.find(t=>t.id===e.id);if(t)return function applyUpdate(e,t){e.content=t.content??e.content,e.summary=t.summary??e.summary,e.status=t.status??e.status,e.confidence=normalizeConfidence(t.confidence??e.confidence),e.tags=t.tags??e.tags,e.metadata=t.metadata?{...e.metadata,...t.metadata}:e.metadata,e.lastConfirmedAt=(new Date).toISOString(),e.revision+=1}(t,e),cloneRecord(t)},async archive(e,t){const n=o.find(t=>t.id===e);if(n)return n.status="archived",n.metadata={...n.metadata,archiveReason:t},n.revision+=1,cloneRecord(n)}}}function cloneRecord(e){return n([e])[0]}function createRecord(t){const n=(new Date).toISOString();return{id:e(),namespace:t.namespace,canonicalKey:(r=t.namespace,o=t.content,`${r}:${o.trim().toLowerCase().replace(/\s+/gu," ").slice(0,120)}`),kind:t.kind??"semantic",scope:t.scope??"workspace",status:"active",content:t.content,summary:t.summary,confidence:normalizeConfidence(t.confidence),sourceType:t.sourceType,sourceRefs:t.sourceRef?[t.sourceRef]:[],tags:t.tags??[],sensitivity:t.sensitivity??"internal",metadata:t.metadata??{},createdAt:n,observedAt:t.observedAt??n,lastConfirmedAt:n,provenance:t.provenance??{},revision:1,supersedes:[],conflictsWith:[],retrievalPriority:t.retrievalPriority??0};var r,o}function filterRecords(e,t){return e.filter(e=>e.namespace===t.namespace).filter(e=>!t.kinds||t.kinds.includes(e.kind)).filter(e=>!t.scopes||t.scopes.includes(e.scope)).filter(e=>(t.statuses??["active"]).includes(e.status))}function compareRecallPriority(e,t){return t.retrievalPriority-e.retrievalPriority||t.confidence-e.confidence||t.lastConfirmedAt.localeCompare(e.lastConfirmedAt)}function buildMemoryContext(e){return e.map(e=>`- [${e.kind}/${e.scope}] ${e.summary??e.content}`).join("\n")}function normalizeConfidence(e){return void 0===e||Number.isNaN(e)?.6:Math.min(1,Math.max(0,e))}

package/node_modules/@stable-harness/memory/dist/src/types.d.ts

@@ -0,0 +1,138 @@
+export type MemoryKind = "semantic" | "episodic" | "procedural";
+export type MemoryScope = "session" | "agent" | "workspace" | "user" | "project";
+export type MemoryRecordStatus = "active" | "stale" | "conflicted" | "archived" | "pending_review";
+export type MemorySensitivity = "public" | "internal" | "sensitive" | "restricted";
+export type MemoryDecisionAction = "reject" | "store" | "merge" | "refresh" | "supersede" | "archive" | "review";
+export type MemoryCandidate = {
+    namespace: string;
+    content: string;
+    sourceType?: string;
+    sourceRef?: string;
+    kindHint?: MemoryKind;
+    summary?: string;
+    scopeHint?: MemoryScope;
+    confidenceHint?: number;
+    tags?: string[];
+    sensitivity?: MemorySensitivity;
+    noStore?: boolean;
+    provenance?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    observedAt?: string;
+};
+export type MemoryDecision = {
+    action: MemoryDecisionAction;
+    reason: string;
+    recordId?: string;
+    kind?: MemoryKind;
+    scope?: MemoryScope;
+    confidence?: number;
+    ttlDays?: number;
+    retrievalPriority?: number;
+    reviewRequired?: boolean;
+};
+export type MemoryRecord = {
+    id: string;
+    namespace: string;
+    canonicalKey: string;
+    kind: MemoryKind;
+    scope: MemoryScope;
+    status: MemoryRecordStatus;
+    content: string;
+    summary?: string;
+    confidence: number;
+    sourceType?: string;
+    sourceRefs: string[];
+    tags: string[];
+    sensitivity: MemorySensitivity;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    observedAt: string;
+    lastConfirmedAt: string;
+    expiresAt?: string;
+    provenance: Record<string, unknown>;
+    revision: number;
+    supersedes: string[];
+    conflictsWith: string[];
+    retrievalPriority: number;
+};
+export type MemorizeInput = {
+    namespace: string;
+    content: string;
+    kind?: MemoryKind;
+    scope?: MemoryScope;
+    summary?: string;
+    confidence?: number;
+    tags?: string[];
+    sensitivity?: MemorySensitivity;
+    sourceType?: string;
+    sourceRef?: string;
+    metadata?: Record<string, unknown>;
+    provenance?: Record<string, unknown>;
+    observedAt?: string;
+    retrievalPriority?: number;
+};
+export type MemorySubmitResult = {
+    candidate: MemoryCandidate;
+    decision: MemoryDecision;
+    record?: MemoryRecord;
+};
+export type RecallInput = {
+    namespace: string;
+    query: string;
+    limit?: number;
+    kinds?: MemoryKind[];
+    scopes?: MemoryScope[];
+    statuses?: MemoryRecordStatus[];
+};
+export type MemoryRecallResult = {
+    records: MemoryRecord[];
+    context: string;
+};
+export type MemoryStoreSnapshot = {
+    namespace: string;
+    records: MemoryRecord[];
+    exportedAt: string;
+};
+export type MemoryPersistenceAdapter = {
+    load(namespace: string): Promise<MemoryRecord[]>;
+    save(snapshot: MemoryStoreSnapshot): Promise<void>;
+};
+export type MemoryMaintenanceAction = "mark_stale" | "archive" | "refresh" | "supersede";
+export type MemoryMaintenanceOperation = {
+    action: MemoryMaintenanceAction;
+    recordId: string;
+    reason: string;
+    replacementRecordId?: string;
+};
+export type MemoryMaintenanceResult = {
+    operation: MemoryMaintenanceOperation;
+    record?: MemoryRecord;
+    applied: boolean;
+    reason: string;
+};
+export type ListMemoriesInput = {
+    namespace: string;
+    kinds?: MemoryKind[];
+    scopes?: MemoryScope[];
+    statuses?: MemoryRecordStatus[];
+};
+export type UpdateMemoryInput = {
+    id: string;
+    content?: string;
+    summary?: string;
+    status?: MemoryRecordStatus;
+    confidence?: number;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+};
+export type MemoryPolicy = {
+    decide(candidate: MemoryCandidate): MemoryDecision;
+};
+export type RuntimeMemoryStore = {
+    submitCandidate(candidate: MemoryCandidate): Promise<MemorySubmitResult>;
+    memorize(input: MemorizeInput): Promise<MemoryRecord>;
+    recall(input: RecallInput): Promise<MemoryRecallResult>;
+    list(input: ListMemoriesInput): Promise<MemoryRecord[]>;
+    update(input: UpdateMemoryInput): Promise<MemoryRecord | undefined>;
+    archive(id: string, reason?: string): Promise<MemoryRecord | undefined>;
+};

package/node_modules/@stable-harness/memory/dist/src/types.js

@@ -0,0 +1 @@
+export{};

package/node_modules/@stable-harness/memory/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@stable-harness/memory",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "package.json"
+  ],
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts"
+}

package/node_modules/@stable-harness/protocols/dist/src/http-server.d.ts

@@ -0,0 +1,3 @@
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import { type StableHarnessRuntime } from "@stable-harness/core";
+export declare function createHttpServer(runtime: StableHarnessRuntime): import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/node_modules/@stable-harness/protocols/dist/src/http-server.js

@@ -0,0 +1 @@
+import{createServer as t}from"node:http";import{compileWorkflowPlan as e,projectRuntimeTrace as r,renderWorkflowMermaid as o}from"@stable-harness/core";export function createHttpServer(n){return t(async(t,s)=>{try{if("GET"===t.method&&"/health"===t.url)return void sendJson(s,200,{ok:!0});if("GET"===t.method&&"/inspect"===t.url)return void sendJson(s,200,n.inspect());if("GET"===t.method&&"/requests"===t.url)return void sendJson(s,200,n.listRequests());if("GET"===t.method&&"/sessions"===t.url)return void sendJson(s,200,n.listSessions());const a=function readArtifactList(t){if(!t?.startsWith("/artifacts"))return;const e=new URL(t,"http://stable-harness.local");return"/artifacts"===e.pathname?{...e.searchParams.get("requestId")?{requestId:e.searchParams.get("requestId")}:{},...e.searchParams.get("sessionId")?{sessionId:e.searchParams.get("sessionId")}:{},...e.searchParams.get("agentId")?{agentId:e.searchParams.get("agentId")}:{}}:void 0}(t.url);if("GET"===t.method&&a)return void sendJson(s,200,n.listArtifacts(a));const d=function readArtifactContentId(t){const e=(t??"").match(/^\/artifacts\/([^/]+)\/content$/u);return e?.[1]?decodeURIComponent(e[1]):void 0}(t.url);if("GET"===t.method&&d){const t=n.getArtifact(d),e=n.readArtifact(d);return void sendJson(s,t&&void 0!==e?200:404,t&&void 0!==e?{artifact:t,content:e}:{error:"artifact_content_not_found"})}const i=function readArtifactId(t){const e=(t??"").match(/^\/artifacts\/([^/]+)$/u);return e?.[1]?decodeURIComponent(e[1]):void 0}(t.url);if("GET"===t.method&&i){const t=n.getArtifact(i);return void sendJson(s,t?200:404,t??{error:"artifact_not_found"})}const c=function readApprovalList(t){if(!t?.startsWith("/approvals"))return;const e=new URL(t,"http://stable-harness.local");if("/approvals"!==e.pathname)return;const r=e.searchParams.get("status");return{status:"pending"===r||"approved"===r||"rejected"===r?r:void 0}}(t.url);if("GET"===t.method&&c)return void sendJson(s,200,await n.listApprovals(c.status));const u=function readApprovalDecision(t){const e=(t??"").match(/^\/approvals\/([^/]+)\/(approve|reject)$/u);if(e?.[1]&&e[2])return{id:decodeURIComponent(e[1]),status:"approve"===e[2]?"approved":"rejected"}}(t.url);if("POST"===t.method&&u){const t=await n.resolveApproval(u.id,u.status);return void sendJson(s,t?200:404,t??{error:"approval_not_found"})}if("GET"===t.method&&"/workflows"===t.url)return void sendJson(s,200,n.inspect().workflows);const f=function readWorkflowMermaidId(t){const e=(t??"").match(/^\/workflows\/([^/]+)\/mermaid$/u);return e?.[1]?decodeURIComponent(e[1]):void 0}(t.url);if("GET"===t.method&&f){const t=n.getWorkflow(f);return void sendJson(s,t?200:404,t?{mermaid:o(t)}:{error:"workflow_not_found"})}const l=function readWorkflowPlanId(t){const e=(t??"").match(/^\/workflows\/([^/]+)\/plan$/u);return e?.[1]?decodeURIComponent(e[1]):void 0}(t.url);if("GET"===t.method&&l){const t=n.getWorkflow(l);return void sendJson(s,t?200:404,t?e(t):{error:"workflow_not_found"})}const p=function readRequestInspectionId(t){const e=(t??"").match(/^\/requests\/([^/]+)$/u);return e?.[1]?decodeURIComponent(e[1]):void 0}(t.url);if("GET"===t.method&&p){const t=n.inspectRequest(p);return void sendJson(s,t?200:404,t??{error:"request_not_found"})}const m=function readTraceRequestId(t){const e=(t??"").match(/^\/runs\/([^/]+)\/trace$/u);return e?.[1]?decodeURIComponent(e[1]):void 0}(t.url);if("GET"===t.method&&m){const t=n.getRun(m);return void sendJson(s,t?200:404,t?r(t):{error:"run_not_found"})}const h=function readReplayRequestId(t){const e=(t??"").match(/^\/requests\/([^/]+)\/replay$/u);return e?.[1]?decodeURIComponent(e[1]):void 0}(t.url);if("GET"===t.method&&h){const t=n.exportReplayBundle(h);return void sendJson(s,t?200:404,t??{error:"run_not_found"})}if("POST"===t.method&&"/requests"===t.url){const e=await async function readJson(t){const e=[];for await(const r of t)e.push(Buffer.isBuffer(r)?r:Buffer.from(r));return 0===e.length?{}:JSON.parse(Buffer.concat(e).toString("utf8"))}(t);return void sendJson(s,200,await n.request(function readRuntimeRequest(t){const e=function readToolCall(t){if("object"!=typeof t||null===t)return;const e=t;return"string"==typeof e.toolId?{toolId:e.toolId,args:e.args}:void 0}(t.toolCall),r=function readWorkflow(t){const e=readRecord(t);if(e)return{..."string"==typeof e.workflowId?{workflowId:e.workflowId}:{},..."string"==typeof e.routeId?{routeId:e.routeId}:{},...void 0!==e.input?{input:e.input}:{},..."object"==typeof e.metadata&&e.metadata?{metadata:e.metadata}:{}}}(t.workflow),o=function readMemory(t){const e=readRecord(t);if(e)return{..."string"==typeof e.namespace?{namespace:e.namespace}:{},...!1===e.recall||readRecord(e.recall)?{recall:e.recall}:{},...Array.isArray(e.candidates)?{candidates:e.candidates}:{}}}(t.memory),n=readRecord(t.metadata);return{input:"string"==typeof t.input?t.input:"",..."string"==typeof t.agentId?{agentId:t.agentId}:{},..."string"==typeof t.sessionId?{sessionId:t.sessionId}:{},..."string"==typeof t.requestId?{requestId:t.requestId}:{},..."string"==typeof t.parentRunId?{parentRunId:t.parentRunId}:{},...e?{toolCall:e}:{},...r?{workflow:r}:{},...o?{memory:o}:{},...n?{metadata:n}:{}}}(e)))}sendJson(s,404,{error:"not_found"})}catch(t){sendJson(s,500,{error:t instanceof Error?t.message:String(t)})}})}function readRecord(t){return"object"!=typeof t||null===t||Array.isArray(t)?void 0:t}function sendJson(t,e,r){t.writeHead(e,{"content-type":"application/json"}),t.end(JSON.stringify(r))}

package/node_modules/@stable-harness/protocols/dist/src/in-process-client.d.ts

@@ -0,0 +1,2 @@
+import type { StableHarnessRuntime } from "@stable-harness/core";
+export declare function createInProcessClient(runtime: StableHarnessRuntime): StableHarnessRuntime;

package/node_modules/@stable-harness/protocols/dist/src/in-process-client.js

@@ -0,0 +1 @@
+export function createInProcessClient(e){return{request:t=>e.request(t),subscribe:t=>e.subscribe(t),inspect:()=>e.inspect(),getRuntimePolicy:()=>e.getRuntimePolicy(),getWorkflow:t=>e.getWorkflow(t),getRun:t=>e.getRun(t),listArtifacts:t=>e.listArtifacts(t),getArtifact:t=>e.getArtifact(t),readArtifact:t=>e.readArtifact(t),exportReplayBundle:t=>e.exportReplayBundle(t),listRequests:t=>e.listRequests(t),listSessions:()=>e.listSessions(),inspectRequest:t=>e.inspectRequest(t),listApprovals:t=>e.listApprovals(t),getApproval:t=>e.getApproval(t),resolveApproval:(t,s)=>e.resolveApproval(t,s),cancel:(t,s)=>e.cancel(t,s),stop:()=>e.stop()}}

package/node_modules/@stable-harness/protocols/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { createInProcessClient } from "./in-process-client.js";
+export { createHttpServer } from "./http-server.js";
+export { createOpenAiCompatibleHttpServer } from "./openai-compatible.js";
+export type { OpenAiCompatibleServerOptions } from "./openai-compatible.js";

package/node_modules/@stable-harness/protocols/dist/src/index.js

@@ -0,0 +1 @@
+export{createInProcessClient}from"./in-process-client.js";export{createHttpServer}from"./http-server.js";export{createOpenAiCompatibleHttpServer}from"./openai-compatible.js";

package/node_modules/@stable-harness/protocols/dist/src/openai-compatible.d.ts

@@ -0,0 +1,9 @@
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import type { StableHarnessRuntime } from "@stable-harness/core";
+export type OpenAiCompatibleServerOptions = {
+    bearerToken?: string;
+    corsOrigins?: string[];
+    modelAgentMap?: Record<string, string>;
+    defaultModel?: string;
+};
+export declare function createOpenAiCompatibleHttpServer(runtime: StableHarnessRuntime, options?: OpenAiCompatibleServerOptions): import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/node_modules/@stable-harness/protocols/dist/src/openai-compatible.js

@@ -0,0 +1 @@
+import{createServer as e}from"node:http";import{createCapabilitiesResponse as r,createModelsResponse as t,resolveAgentId as o,toChatCompletion as n,toRuntimeRequest as a}from"./openai-payload.js";import{createContentChunk as s,createRoleChunk as i,createStopChunk as d,missingFinalDelta as c,writeChatSse as l,writeRuntimeStreamEvent as u,writeSseHeaders as p}from"./openai-stream.js";export function createOpenAiCompatibleHttpServer(f,m={}){const h=function resolveServerOptions(e,r){const t=function readOpenAiProtocolConfig(e){const r=readRecord(e)??{};return readRecord(r.openaiCompatible)??readRecord(r["openai-compatible"])??readRecord(r.openai)??{}}(e.getRuntimePolicy().protocols);return{bearerToken:r.bearerToken??readConfigString(t.bearerToken),corsOrigins:r.corsOrigins??(o=t.corsOrigins,Array.isArray(o)?o.filter(e=>"string"==typeof e&&e.trim().length>0):void 0),modelAgentMap:r.modelAgentMap??readStringRecord(t.modelAgentMap),defaultModel:r.defaultModel??readConfigString(t.defaultModel)};var o}(f,m);return e(async(e,m)=>{try{if(function applyCorsHeaders(e,r,t){const o=function allowedCorsOrigin(e,r){if(e)return r.corsOrigins?.includes("*")?"*":r.corsOrigins?.includes(e)||function isLoopbackOrigin(e){try{const r=new URL(e);return"http:"===r.protocol&&["localhost","127.0.0.1","[::1]"].includes(r.hostname)}catch{return!1}}(e)?e:void 0}(e.headers.origin,t);o&&(r.setHeader("access-control-allow-origin",o),r.setHeader("vary","origin"))}(e,m,h),function handleCors(e,r){return"OPTIONS"===e.method&&(r.writeHead(204,{"access-control-allow-headers":"authorization, content-type, idempotency-key","access-control-allow-methods":"GET, POST, OPTIONS"}),r.end(),!0)}(e,m))return;if(!function isAuthorized(e,r){return!r.bearerToken||e.headers.authorization===`Bearer ${r.bearerToken}`}(e,h))return void sendJson(m,401,{error:{message:"unauthorized",type:"invalid_request_error"}});if("GET"===e.method&&"/v1/models"===e.url)return void sendJson(m,200,t(f,h));if("GET"===e.method&&"/v1/capabilities"===e.url)return void sendJson(m,200,r());const v=function readApprovalList(e){if(!e?.startsWith("/v1/approvals"))return;const r=new URL(e,"http://stable-harness.local");if("/v1/approvals"!==r.pathname)return;const t=r.searchParams.get("status");return{status:"pending"===t||"approved"===t||"rejected"===t?t:void 0}}(e.url);if("GET"===e.method&&v)return void sendJson(m,200,{data:await f.listApprovals(v.status)});const g=function readApprovalDecision(e){const r=(e??"").match(/^\/v1\/approvals\/([^/]+)\/(approve|reject)$/u);if(r?.[1]&&r[2])return{id:decodeURIComponent(r[1]),status:"approve"===r[2]?"approved":"rejected"}}(e.url);if("POST"===e.method&&g){const e=await f.resolveApproval(g.id,g.status);return void sendJson(m,e?200:404,e?{data:e}:{error:{message:"approval_not_found",type:"invalid_request_error"}})}if("POST"===e.method&&"/v1/chat/completions"===e.url)return void await async function handleChatCompletion(e,r,t,f){const m=await async function readJson(e){const r=[];for await(const t of e)r.push(Buffer.isBuffer(t)?t:Buffer.from(t));return 0===r.length?{}:JSON.parse(Buffer.concat(r).toString("utf8"))}(r);if(m.model&&!o(m.model,e,f))return void sendJson(t,404,{error:{message:`model_not_found: ${m.model}`,type:"invalid_request_error"}});const h=a(m,e,f,{sessionId:readHeaderString(r.headers["x-stable-harness-session-id"])});if(m.stream)return void await async function streamChatCompletion(e,r,t,o){p(r,{"access-control-allow-headers":"authorization, content-type, idempotency-key","access-control-allow-methods":"GET, POST, OPTIONS"}),l(r,i(o.requestId,t.model));let n="";const a=e.subscribe(e=>{e.requestId===o.requestId&&(n+=u(r,e,o.requestId,t.model)??"")});try{const a=await e.request(o),i=c(n,a.output);i&&l(r,s(o.requestId,t.model,i)),l(r,d(o.requestId,t.model)),r.write("data: [DONE]\n\n"),r.end()}finally{a()}}(e,t,m,h);const v=await e.request(h);sendJson(t,200,n(m,v))}(f,e,m,h);sendJson(m,404,{error:{message:"not_found",type:"invalid_request_error"}})}catch(e){sendJson(m,400,{error:{message:e instanceof Error?e.message:String(e),type:"invalid_request_error"}})}})}function readRecord(e){return"object"!=typeof e||null===e||Array.isArray(e)?void 0:e}function readStringRecord(e){const r=readRecord(e);if(r)return Object.fromEntries(Object.entries(r).filter(e=>"string"==typeof e[1]))}function readConfigString(e){if("string"!=typeof e||!e.trim())return;const r=e.match(/^\$\{env:([A-Za-z_][A-Za-z0-9_]*)(?::-(.*))?\}$/u);return r?process.env[r[1]]??r[2]:e}function readHeaderString(e){const r=Array.isArray(e)?e[0]:e;return r&&r.trim()?r:void 0}function sendJson(e,r,t,o){e.writeHead(r,{"content-type":"application/json","access-control-allow-headers":"authorization, content-type, idempotency-key","access-control-allow-methods":"GET, POST, OPTIONS"}),e.end(JSON.stringify(t))}

package/node_modules/@stable-harness/protocols/dist/src/openai-payload.d.ts

@@ -0,0 +1,74 @@
+import type { RuntimeResponse, StableHarnessRuntime } from "@stable-harness/core";
+import type { OpenAiCompatibleServerOptions } from "./openai-compatible.js";
+export type ChatMessage = {
+    role?: string;
+    content?: unknown;
+};
+export type ChatCompletionRequest = {
+    model?: string;
+    messages?: ChatMessage[];
+    stream?: boolean;
+    user?: string;
+    metadata?: Record<string, unknown>;
+};
+export type ChatProtocolContext = {
+    sessionId?: string;
+};
+export declare function toRuntimeRequest(body: ChatCompletionRequest, runtime: StableHarnessRuntime, options: OpenAiCompatibleServerOptions, context?: ChatProtocolContext): {
+    metadata: {
+        protocol: string;
+        openaiStream: boolean;
+        openaiMessages: {
+            role: string;
+            content: string;
+        }[];
+        openaiSessionHistory: boolean;
+        model: string | undefined;
+        user: string | undefined;
+        clientMetadata: Record<string, unknown> | undefined;
+    };
+    sessionId?: string | undefined;
+    input: string;
+    requestId: string;
+    agentId: string | undefined;
+};
+export declare function resolveAgentId(model: string | undefined, runtime: StableHarnessRuntime, options: OpenAiCompatibleServerOptions): string | undefined;
+export declare function createModelsResponse(runtime: StableHarnessRuntime, options: OpenAiCompatibleServerOptions): {
+    object: string;
+    data: {
+        id: string;
+        object: string;
+        created: number;
+        owned_by: string;
+    }[];
+};
+export declare function createCapabilitiesResponse(): {
+    object: string;
+    endpoints: string[];
+    streaming: boolean;
+    toolProgressEvents: boolean;
+};
+export declare function toChatCompletion(body: ChatCompletionRequest, result: RuntimeResponse): {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        message: {
+            role: string;
+            content: string;
+        };
+        finish_reason: string;
+    }[];
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    metadata: {
+        sessionId: string;
+        agentId: string;
+        state: import("@stable-harness/core").RuntimeRecordState;
+    };
+};

package/node_modules/@stable-harness/protocols/dist/src/openai-payload.js

@@ -0,0 +1 @@
+import{randomUUID as e}from"node:crypto";export function toRuntimeRequest(t,n,s,o={}){const r=function messagesToInput(e){if(!Array.isArray(e)||0===e.length)throw new Error("messages must be a non-empty array");return e.map(e=>`${e.role??"user"}: ${contentToText(e.content)}`).join("\n\n")}(t.messages),a=`chatcmpl-${e()}`,i=o.sessionId??function readSessionId(e){const t=e?.sessionId??e?.session_id??e?.conversationId??e?.conversation_id;return"string"==typeof t&&t.trim()?t:void 0}(t.metadata),c=normalizeOpenAiMessages(t.messages),u=i?function prependSessionMessages(e,t,n){if(function hasClientHistory(e){return e.some(e=>"assistant"===e.role)||e.filter(e=>"user"===e.role).length>1}(n))return n;const s=e.listRequests({sessionId:t,state:"completed"}).flatMap(t=>function inspectSessionTurn(e,t){const n=e.inspectRequest(t),s=n?.output?.trim(),o=function lastUserMessage(e){return normalizeOpenAiMessages(Array.isArray(e)?e:void 0).filter(e=>"user"===e.role&&e.content.trim()).at(-1)}(n?.metadata?.openaiMessages)?.content;return o&&s?[{role:"user",content:o},{role:"assistant",content:s}]:[]}(e,t.requestId)).slice(-12);return s.length>0?[...s,...n]:n}(n,i,c):c;return{input:r,requestId:a,agentId:resolveAgentId(t.model,n,s),...i?{sessionId:i}:{},metadata:{protocol:"openai-compatible",openaiStream:!0===t.stream,openaiMessages:u,openaiSessionHistory:u.length>c.length,model:t.model,user:t.user,clientMetadata:t.metadata}}}export function resolveAgentId(e,t,n){if(!e)return;const s=n.modelAgentMap?.[e];return s||(t.inspect().agents.includes(e)?e:void 0)}export function createModelsResponse(e,t){const n=Object.keys(t.modelAgentMap??{});return{object:"list",data:[...new Set([...e.inspect().agents,...n])].sort().map(e=>({id:e,object:"model",created:0,owned_by:"stable-harness"}))}}export function createCapabilitiesResponse(){return{object:"stable_harness.capabilities",endpoints:["/v1/models","/v1/chat/completions","/v1/capabilities"],streaming:!0,toolProgressEvents:!0}}export function toChatCompletion(e,t){return{id:t.requestId,object:"chat.completion",created:Math.floor(Date.now()/1e3),model:e.model??t.agentId,choices:[{index:0,message:{role:"assistant",content:t.output},finish_reason:"stop"}],usage:estimateUsage(e.messages,t.output),metadata:{sessionId:t.sessionId,agentId:t.agentId,state:t.state}}}function normalizeOpenAiMessages(e){return Array.isArray(e)?e.map(e=>({role:e.role??"user",content:contentToText(e.content)})):[]}function contentToText(e){if("string"==typeof e)return e;if(!Array.isArray(e))throw new Error("message content must be a string or content part array");return e.map(contentPartToText).join("\n")}function contentPartToText(e){if("object"!=typeof e||null===e)throw new Error("message content parts must be objects");const t=e;if("text"===t.type&&"string"==typeof t.text)return t.text;const n=t.image_url;if("image_url"===t.type&&"string"==typeof n?.url)return`[image:${n.url}]`;throw new Error("unsupported_content_type")}function estimateUsage(e,t){const n=estimateTokens(Array.isArray(e)?e.map(e=>contentToText(e.content)).join("\n"):""),s=estimateTokens(t);return{prompt_tokens:n,completion_tokens:s,total_tokens:n+s}}function estimateTokens(e){return e.trim()?Math.ceil(1.3*e.trim().split(/\s+/u).length):0}

package/node_modules/@stable-harness/protocols/dist/src/openai-stream.d.ts

@@ -0,0 +1,39 @@
+import type { ServerResponse } from "node:http";
+import type { RuntimeEvent } from "@stable-harness/core";
+export declare function missingFinalDelta(streamedContent: string, finalOutput: string): string;
+export declare function createRoleChunk(id: string, model: string | undefined): {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        delta: Record<string, unknown>;
+        finish_reason: string | null;
+    }[];
+};
+export declare function createContentChunk(id: string, model: string | undefined, content: string): {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        delta: Record<string, unknown>;
+        finish_reason: string | null;
+    }[];
+};
+export declare function createStopChunk(id: string, model: string | undefined): {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        delta: Record<string, unknown>;
+        finish_reason: string | null;
+    }[];
+};
+export declare function writeRuntimeStreamEvent(response: ServerResponse, event: RuntimeEvent, id: string, model: string | undefined): string | undefined;
+export declare function writeSseHeaders(response: ServerResponse, headers: Record<string, string>): void;
+export declare function writeChatSse(response: ServerResponse, body: unknown): void;

package/node_modules/@stable-harness/protocols/dist/src/openai-stream.js

@@ -0,0 +1 @@
+export function missingFinalDelta(e,t){return e?!t||e.includes(t)?"":t.startsWith(e)?t.slice(e.length):t:t}export function createRoleChunk(e,t){return createChunk(e,t,{role:"assistant"},null)}export function createContentChunk(e,t,n){return createChunk(e,t,{content:n},null)}export function createStopChunk(e,t){return createChunk(e,t,{},"stop")}export function writeRuntimeStreamEvent(e,t,n,r){const o=function readAdapterDelta(e){if("runtime.adapter.event"!==e.type||"object"!=typeof e.event||null===e.event)return;const t=e.event;return"agent.output.delta"===t.phase&&"string"==typeof t.text?t.text:void 0}(t);if(o)return writeChatSse(e,createContentChunk(n,r,o)),o;!function writeProgressEvent(e,t){const n=function readToolProgress(e){if("runtime.tool.direct.started"===e.type||"runtime.tool.direct.completed"===e.type)return{request_id:e.requestId,session_id:e.sessionId,agent_id:e.agentId,type:e.type,tool_id:e.toolId};if("runtime.adapter.event"!==e.type||"object"!=typeof e.event||null===e.event)return;const t=e.event,n="agent.tool.start"===t.phase||"agent.tool.result"===t.phase?t.phase:void 0,r="string"==typeof t.toolId?t.toolId:void 0;return n&&r?{request_id:e.requestId,session_id:e.sessionId,agent_id:e.agentId,type:n,tool_id:r,adapter:t.adapter}:void 0}(t);n&&writeSse(e,"stable_harness.tool.progress",n)}(e,t),function writeNarrationEvent(e,t){"runtime.progress.narration"===t.type&&writeSse(e,"stable_harness.progress.narration",{request_id:t.requestId,session_id:t.sessionId,agent_id:t.agentId,type:t.type,message:t.message,provider:t.provider,source_event_types:t.sourceEventTypes,source_event_ids:t.sourceEventIds,model:t.model,style:t.style})}(e,t)}export function writeSseHeaders(e,t){e.writeHead(200,{"content-type":"text/event-stream","cache-control":"no-cache",connection:"keep-alive",...t})}export function writeChatSse(e,t){e.write(`data: ${JSON.stringify(t)}\n\n`)}function createChunk(e,t,n,r){return{id:e,object:"chat.completion.chunk",created:Math.floor(Date.now()/1e3),model:t??"stable-harness",choices:[{index:0,delta:n,finish_reason:r}]}}function writeSse(e,t,n){e.write(`event: ${t}\n`),e.write(`data: ${JSON.stringify(n)}\n\n`)}

package/node_modules/@stable-harness/protocols/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@stable-harness/protocols",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "package.json"
+  ],
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "peerDependencies": {
+    "@stable-harness/core": "0.0.1"
+  }
+}

package/node_modules/@stable-harness/tool-gateway/dist/src/argument-guard.d.ts

@@ -0,0 +1,33 @@
+import type { BetterToolLike, RepairFunction, RepairModelLike, RepairPolicy } from "@botbotgo/better-call";
+import type { ToolArgumentGuard, ToolArgumentIssue, ToolGatewayContext, ToolGatewayTool } from "./types.js";
+type ToolGatewayRuntimeTool = ToolGatewayTool & {
+    validationTool?: BetterToolLike;
+};
+export type BetterCallArgumentRepairOptions = {
+    mode?: "guard" | "repair" | "review";
+    repair?: RepairFunction;
+    repairModel?: RepairModelLike;
+    repairPolicy?: RepairPolicy;
+};
+export type ToolArgumentGuardOptions = {
+    betterCall?: BetterCallArgumentRepairOptions;
+};
+export type BetterCallToolSelectionRepair = {
+    toolId: string;
+    args: unknown;
+};
+export declare class ToolArgumentValidationError extends Error {
+    readonly toolId: string;
+    readonly issues: ToolArgumentIssue[];
+    constructor(toolId: string, issues: ToolArgumentIssue[]);
+}
+export declare function createDefaultArgumentGuard(options?: ToolArgumentGuardOptions): ToolArgumentGuard;
+export declare function assertToolArguments(tool: ToolGatewayTool, args: unknown, context: ToolGatewayContext, guard: ToolArgumentGuard): Promise<unknown>;
+export declare function prepareBetterCallTools(tools: ToolGatewayTool[], options: BetterCallArgumentRepairOptions | undefined): ToolGatewayRuntimeTool[];
+export declare function repairBetterCallToolSelection(input: {
+    toolId: string;
+    args: unknown;
+    tools: ToolGatewayTool[];
+    options: BetterCallArgumentRepairOptions | undefined;
+}): Promise<BetterCallToolSelectionRepair | undefined>;
+export {};

package/node_modules/@stable-harness/tool-gateway/dist/src/argument-guard.js

@@ -0,0 +1 @@
+import{BetterToolValidationError as o,betterTools as t,defaultRepair as e,reliableToolCalls as a}from"@botbotgo/better-call";import{isRecord as r,validateWithZodSchema as i}from"./schema-validation.js";export class ToolArgumentValidationError extends Error{toolId;issues;constructor(o,t){super(`Tool argument validation failed for ${o}: ${t.map(o=>`${o.path} ${o.message}`).join("; ")}`),this.toolId=o,this.issues=t,this.name="ToolArgumentValidationError"}}export function createDefaultArgumentGuard(t={}){return{async validate(e){const a=e.tool.validateArgs?await e.tool.validateArgs({args:e.args,context:e.context}):{action:"allow",args:e.args};if("reject"===a.action)return a;const r=await async function validateWithBetterCall(t,e,a){const r=i(t.schema,e);if(void 0===t.schema)return r??{action:"allow",args:e};const l=await async function invokeBetterCallValidation(t,e,a){try{return{action:"allow",args:await createBetterCallValidationTool(t,a).invoke(e)}}catch(t){if(t instanceof o)return{action:"reject",reason:"BetterCall validation failed",issues:t.issues.map(toToolArgumentIssue)};throw t}}(t,"allow"===r?.action?r.args:e,a);return r?"allow"===r.action?l:"reject"===l.action?r:i(t.schema,l.args)||l:l}(e.tool,a.args,t.betterCall);return"reject"===r.action?r:"repair"===a.action?{...a,args:r.args}:r}}}export function assertToolArguments(o,t,e,a){return Promise.resolve(a.validate({tool:o,args:t,context:e})).then(t=>{if("reject"===t.action)throw new ToolArgumentValidationError(o.id,t.issues);return t.args})}export function prepareBetterCallTools(o,e){const a=t(o.map(toBetterCallTool),toBetterToolsOptions(e));return o.map((o,t)=>({...o,validationTool:a[t]}))}export async function repairBetterCallToolSelection(o){const t=function resolveRepair(o){return o?.repair??(o?.repairModel?e(o.repairModel):void 0)}(o.options);if(!t||0===o.tools.length)return;const i=await a({userInput:JSON.stringify({tool:o.toolId,args:o.args}),tools:o.tools.map(toToolDefinition),calls:[{tool:o.toolId,args:(l=o.args,r(l)?l:{input:l})}],repair:t,repairPolicy:o.options?.repairPolicy??{allowCoercion:!0,allowClamp:!0,allowArrayStringSplit:!0,allowModelRepair:!0},mode:o.options?.mode??"repair"});var l;const n=i.ok?i.calls.find(t=>o.tools.some(o=>o.id===t.tool)):void 0;return n?{toolId:n.tool,args:n.args}:void 0}function createBetterCallValidationTool(o,e){return o.validationTool??t([toBetterCallTool(o)],toBetterToolsOptions(e))[0]}function toBetterCallTool(o){return{name:o.id,description:o.description,schema:o.schema,invoke:o=>o}}function toToolDefinition(o){return{name:o.id,description:o.description,schema:o.schema}}function toToolArgumentIssue(o){return{path:o.path.replace(/^\$\.calls\[\d+\]\.args/u,"$"),message:o.message,expected:void 0===o.expected?void 0:String(o.expected),actual:o.actual}}function toBetterToolsOptions(o){return{mode:o?.mode??"repair",repair:o?.repair,repairModel:o?.repairModel,repairPolicy:o?.repairPolicy??{allowCoercion:!0,allowClamp:!0,allowArrayStringSplit:!0,allowModelRepair:!0}}}

package/node_modules/@stable-harness/tool-gateway/dist/src/in-memory.d.ts

@@ -0,0 +1,4 @@
+import type { ToolGateway, ToolGatewayTool } from "./types.js";
+import type { ToolArgumentGuardOptions } from "./argument-guard.js";
+export type ToolGatewayOptions = ToolArgumentGuardOptions;
+export declare function createInMemoryToolGateway(tools: ToolGatewayTool[], options?: ToolGatewayOptions): ToolGateway;

package/node_modules/@stable-harness/tool-gateway/dist/src/in-memory.js

@@ -0,0 +1 @@
+import{assertToolArguments as o,createDefaultArgumentGuard as t,prepareBetterCallTools as e,repairBetterCallToolSelection as r,ToolArgumentValidationError as a}from"./argument-guard.js";export function createInMemoryToolGateway(l,i={}){const s=new Map(e(l,i.betterCall).map(o=>[o.id,o])),n=t(i),repairToolCall=async o=>{const t=o.allowedToolIds?new Set(o.allowedToolIds):void 0,e=[...s.values()].filter(o=>!t||t.has(o.id));return r({toolId:o.toolId,args:o.args,tools:e,options:withRequestRepairModel(i.betterCall,o.repairModel)})};return{list:()=>[...s.values()],get:o=>s.get(o),repairToolCall:repairToolCall,async invoke(t){const e=s.has(t.toolId)?void 0:await repairToolCall(t),r=e?.toolId??t.toolId,l=s.get(r);if(!l)throw new Error(`Tool is not registered: ${t.toolId}`);const i=await async function assertToolArgumentsWithRepair(t){try{return await o(t.tool,t.initialArgs,t.request.context,t.guard)}catch(e){if(!(e instanceof a))throw e;const r=await t.repairToolCall({...t.request,args:t.initialArgs,allowedToolIds:[t.tool.id]});if(!r||r.toolId!==t.tool.id)throw e;return o(t.tool,r.args,t.request.context,t.guard)}}({request:t,tool:l,initialArgs:e?.args??t.args,repairToolCall:repairToolCall,guard:n});return{toolId:l.id,output:await l.invoke(i,t.context)}}}}function withRequestRepairModel(o,t){return!t||o?.repair||o?.repairModel?o:{...o,mode:o?.mode??"repair",repairModel:t}}

package/node_modules/@stable-harness/tool-gateway/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export { createDefaultArgumentGuard, ToolArgumentValidationError } from "./argument-guard.js";
+export { createInMemoryToolGateway } from "./in-memory.js";
+export { createModuleToolGateway } from "./module-loader.js";
+export type { BetterCallArgumentRepairOptions, ToolArgumentGuardOptions } from "./argument-guard.js";
+export type { ToolGatewayOptions } from "./in-memory.js";
+export type { ModuleToolDescriptor } from "./module-loader.js";
+export type { ToolArgumentGuard, ToolArgumentGuardResult, ToolArgumentIssue, ToolArgumentValidator, ToolGateway, ToolGatewayContext, ToolGatewayInvokeRequest, ToolGatewayInvokeResult, ToolGatewayRepairRequest, ToolGatewayRepairResult, ToolGatewayTool, } from "./types.js";

package/node_modules/@stable-harness/tool-gateway/dist/src/index.js

@@ -0,0 +1 @@
+export{createDefaultArgumentGuard,ToolArgumentValidationError}from"./argument-guard.js";export{createInMemoryToolGateway}from"./in-memory.js";export{createModuleToolGateway}from"./module-loader.js";

package/node_modules/@stable-harness/tool-gateway/dist/src/module-loader.d.ts

@@ -0,0 +1,13 @@
+import type { ToolGatewayOptions } from "./in-memory.js";
+import type { ToolGateway } from "./types.js";
+export type ModuleToolDescriptor = {
+    id: string;
+    name?: string;
+    description?: string;
+    schema?: unknown;
+    sourcePath?: string;
+};
+export declare function createModuleToolGateway(input: {
+    tools: Iterable<ModuleToolDescriptor>;
+    options?: ToolGatewayOptions;
+}): Promise<ToolGateway>;

package/node_modules/@stable-harness/tool-gateway/dist/src/module-loader.js

@@ -0,0 +1 @@
+import o from"node:path";import{pathToFileURL as e}from"node:url";import{createInMemoryToolGateway as t}from"./in-memory.js";export async function createModuleToolGateway(o){const e=[];for(const t of o.tools){const o=await loadModuleTool(t);o&&e.push(o)}return t(e,o.options)}async function loadModuleTool(t){if(!t.sourcePath)return;const n=await import(e(o.resolve(t.sourcePath)).href),r=n[t.name??t.id]??n.default;return function hasInvoke(o){return"object"==typeof o&&null!==o&&"invoke"in o&&"function"==typeof o.invoke}(r)?{id:t.id,description:t.description??r.description,schema:t.schema??r.schema,validateArgs:r.validateArgs,invoke:(o,e)=>async function invokeWithWorkspaceCwd(o,e,t){const n=process.cwd();try{return process.chdir(t.workspaceRoot),await o(e,t)}finally{process.chdir(n)}}(r.invoke,o,e)}:void 0}

package/node_modules/@stable-harness/tool-gateway/dist/src/schema-validation.d.ts

@@ -0,0 +1,3 @@
+import type { ToolArgumentGuardResult } from "./types.js";
+export declare function validateWithZodSchema(schema: unknown, args: unknown): ToolArgumentGuardResult | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/node_modules/@stable-harness/tool-gateway/dist/src/schema-validation.js

@@ -0,0 +1 @@
+import{normalizeArgsBySchema as e}from"@botbotgo/better-call";export function validateWithZodSchema(t,o){return isZodLike(t)?toZodGuardResult(t.safeParse(o??{})):function isZodShape(e){return isRecord(e)&&Object.values(e).length>0&&Object.values(e).every(isZodLike)}(t)?function validateWithZodShape(t,o){const r=function normalizeZodShapeArgs(t,o){const r=isRecord(o)?o:{};return e(t,r,{allowCoercion:!0,allowClamp:!0,allowArrayStringSplit:!0}).args}(t,o),a={},s=[];for(const[e,o]of Object.entries(t)){const t=o.safeParse(r[e]);t.success?void 0!==t.data&&(a[e]=t.data):s.push(...t.error.issues.map(t=>({...t,path:[e,...t.path]})))}return s.length>0?toZodGuardResult({success:!1,error:{issues:s}}):{action:"allow",args:a}}(t,o):void 0}export function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function toZodGuardResult(e){return e.success?{action:"allow",args:e.data}:{action:"reject",reason:"Zod schema validation failed",issues:e.error.issues.map(e=>{return{path:(t=e.path,t.length>0?`$.${t.map(String).join(".")}`:"$"),message:e.message,expected:"schema"};var t})}}function isZodLike(e){return isRecord(e)&&"function"==typeof e.safeParse}

package/node_modules/@stable-harness/tool-gateway/dist/src/types.d.ts

@@ -0,0 +1,79 @@
+export type ToolGatewayContext = {
+    workspaceRoot: string;
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    requestInput?: string;
+    observedEvidence?: string;
+    approvalIds?: string[];
+    sandbox?: ToolGatewaySandboxDecision;
+};
+export type ToolGatewaySandboxDecision = {
+    action: "allow" | "deny";
+    profile?: string;
+    reason?: string;
+    policyId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type ToolGatewayTool = {
+    id: string;
+    description?: string;
+    schema?: unknown;
+    validateArgs?: ToolArgumentValidator;
+    invoke(args: unknown, context: ToolGatewayContext): Promise<unknown>;
+};
+export type ToolArgumentIssue = {
+    path: string;
+    message: string;
+    expected?: string;
+    actual?: unknown;
+};
+export type ToolArgumentGuardResult = {
+    action: "allow";
+    args: unknown;
+} | {
+    action: "repair";
+    args: unknown;
+    reason: string;
+    issues: ToolArgumentIssue[];
+} | {
+    action: "reject";
+    reason: string;
+    issues: ToolArgumentIssue[];
+};
+export type ToolArgumentGuard = {
+    validate(input: {
+        tool: ToolGatewayTool;
+        args: unknown;
+        context: ToolGatewayContext;
+    }): Promise<ToolArgumentGuardResult> | ToolArgumentGuardResult;
+};
+export type ToolArgumentValidator = (input: {
+    args: unknown;
+    context: ToolGatewayContext;
+}) => Promise<ToolArgumentGuardResult> | ToolArgumentGuardResult;
+export type ToolGatewayInvokeRequest = {
+    toolId: string;
+    args?: unknown;
+    repairModel?: {
+        invoke(input: unknown): Promise<unknown> | unknown;
+    };
+    context: ToolGatewayContext;
+};
+export type ToolGatewayRepairRequest = ToolGatewayInvokeRequest & {
+    allowedToolIds?: string[];
+};
+export type ToolGatewayInvokeResult = {
+    toolId: string;
+    output: unknown;
+};
+export type ToolGatewayRepairResult = {
+    toolId: string;
+    args: unknown;
+};
+export type ToolGateway = {
+    list(): ToolGatewayTool[];
+    get(toolId: string): ToolGatewayTool | undefined;
+    repairToolCall?(request: ToolGatewayRepairRequest): Promise<ToolGatewayRepairResult | undefined>;
+    invoke(request: ToolGatewayInvokeRequest): Promise<ToolGatewayInvokeResult>;
+};

package/node_modules/@stable-harness/tool-gateway/dist/src/types.js

@@ -0,0 +1 @@
+export{};