stable-harness 0.0.1

package/packages/governance/dist/src/types.d.ts

@@ -0,0 +1,100 @@
+export type PolicyDecision = {
+    action: "allow";
+    reason: string;
+} | {
+    action: "require_approval";
+    reason: string;
+};
+export type ToolPolicy = {
+    approvalRequiredToolIds?: string[];
+    sandboxByToolId?: Record<string, string>;
+};
+export type RuntimePolicyEngine = {
+    evaluateTool(input: {
+        toolId: string;
+        metadata?: Record<string, unknown>;
+    }): PolicyDecision;
+    resolveSandbox(input: {
+        toolId: string;
+        defaultSandbox?: string;
+    }): string;
+};
+export type ApprovalRequestKind = "tool_invocation" | "memory_write" | "skill_candidate";
+export type ApprovalRequestStatus = "pending" | "approved" | "rejected";
+export type ApprovalRequest = {
+    id: string;
+    kind: ApprovalRequestKind;
+    reason: string;
+    status: ApprovalRequestStatus;
+    requestId?: string;
+    sessionId?: string;
+    agentId?: string;
+    subject: Record<string, unknown>;
+    createdAt: string;
+    resolvedAt?: string;
+};
+export type ApprovalQueue = {
+    create(input: {
+        kind: ApprovalRequestKind;
+        reason: string;
+        requestId?: string;
+        sessionId?: string;
+        agentId?: string;
+        subject: Record<string, unknown>;
+    }): Promise<ApprovalRequest>;
+    list(status?: ApprovalRequestStatus): Promise<ApprovalRequest[]>;
+    resolve(id: string, status: Exclude<ApprovalRequestStatus, "pending">): Promise<ApprovalRequest | undefined>;
+};
+export type SkillCandidateStatus = "observed" | "candidate" | "review_required" | "approved" | "rejected" | "drafted" | "enabled" | "deprecated";
+export type SkillCandidate = {
+    id: string;
+    workspaceId: string;
+    name: string;
+    status: SkillCandidateStatus;
+    confidence: number;
+    evidenceCount: number;
+    proposedPath?: string;
+    title: string;
+    summary: string;
+    draftMarkdown: string;
+    createdAt: string;
+    updatedAt: string;
+    reviewedAt?: string;
+    reviewedBy?: string;
+    rejectionReason?: string;
+};
+export type SkillCandidateEvidence = {
+    id: string;
+    candidateId: string;
+    evidenceType: "memory_record" | "run" | "tool_event" | "validation" | "user_correction" | "deepagents_memory_file";
+    evidenceRef: string;
+    summary?: string;
+    weight?: number;
+    createdAt: string;
+};
+export type SkillCandidateInput = {
+    workspaceId: string;
+    name: string;
+    status?: SkillCandidateStatus;
+    confidence: number;
+    proposedPath?: string;
+    title: string;
+    summary: string;
+    draftMarkdown: string;
+    evidence: Array<Omit<SkillCandidateEvidence, "id" | "candidateId" | "createdAt">>;
+};
+export type SkillCandidateStore = {
+    upsert(input: SkillCandidateInput): Promise<SkillCandidate>;
+    list(filter?: {
+        workspaceId?: string;
+        status?: SkillCandidateStatus;
+    }): Promise<SkillCandidate[]>;
+    get(id: string): Promise<SkillCandidate | undefined>;
+    listEvidence(candidateId: string): Promise<SkillCandidateEvidence[]>;
+    updateStatus(input: {
+        id: string;
+        status: SkillCandidateStatus;
+        reviewedBy?: string;
+        rejectionReason?: string;
+    }): Promise<SkillCandidate | undefined>;
+};

package/packages/governance/dist/src/types.js

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

package/packages/governance/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@stable-harness/governance",
+  "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/packages/memory/dist/src/index.d.ts

@@ -0,0 +1,9 @@
+export { applyMemoryMaintenance } from "./maintenance.js";
+export { createEmbeddedMemoryProvider, } from "./provider.js";
+export { createLangMemServiceProvider, } from "./langmem-service.js";
+export type { LangMemServiceProviderOptions, } from "./langmem-service.js";
+export type { MemoryProvider, MemoryProviderApprovalConfig, MemoryProviderConfig, MemoryProviderConsolidateInput, MemoryProviderDefaults, MemoryProviderMode, MemoryProviderProposeInput, MemoryProviderSearchInput, MemoryProviderTypeConfig, } from "./provider.js";
+export { cloneRecords, createInMemoryMemoryPersistenceAdapter, createMemorySnapshot, } from "./persistence.js";
+export { createDefaultMemoryPolicy } from "./policy.js";
+export { createInMemoryRuntimeMemoryStore } from "./store.js";
+export type { ListMemoriesInput, MemorizeInput, MemoryCandidate, MemoryDecision, MemoryDecisionAction, MemoryKind, MemoryMaintenanceAction, MemoryMaintenanceOperation, MemoryMaintenanceResult, MemoryPolicy, MemoryPersistenceAdapter, MemoryRecallResult, MemoryRecord, MemoryRecordStatus, MemoryScope, MemorySensitivity, MemoryStoreSnapshot, MemorySubmitResult, RecallInput, RuntimeMemoryStore, UpdateMemoryInput, } from "./types.js";

package/packages/memory/dist/src/index.js

@@ -0,0 +1 @@
+export{applyMemoryMaintenance}from"./maintenance.js";export{createEmbeddedMemoryProvider}from"./provider.js";export{createLangMemServiceProvider}from"./langmem-service.js";export{cloneRecords,createInMemoryMemoryPersistenceAdapter,createMemorySnapshot}from"./persistence.js";export{createDefaultMemoryPolicy}from"./policy.js";export{createInMemoryRuntimeMemoryStore}from"./store.js";

package/packages/memory/dist/src/langmem-service.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryProvider, MemoryProviderConfig } from "./provider.js";
+export type LangMemServiceProviderOptions = {
+    baseUrl: string;
+    config?: MemoryProviderConfig;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+};
+export declare function createLangMemServiceProvider(options: LangMemServiceProviderOptions): MemoryProvider;

package/packages/memory/dist/src/langmem-service.js

@@ -0,0 +1 @@
+export function createLangMemServiceProvider(r){const t=function(e){return e.replace(/\/+$/u,"")}(r.baseUrl),a={...r.config,provider:"langmem-service"};return{name:"langmem-service",config:a,propose:async n=>(await e(t,"/memory/propose",{...n,config:a},r)).candidates??[],async search(o){const i=await(o.store?.list({namespace:o.namespace,kinds:o.kinds}))??[];return(await e(t,"/memory/search",{...n(o),records:i,config:a},r)).records??[]},consolidate:async n=>(await e(t,"/memory/consolidate",{...n,config:a},r)).operations??[]}}async function e(e,n,r,t){const a=new AbortController,o=setTimeout(()=>a.abort(),t.timeoutMs??3e4);try{const o=await fetch(`${e}${n}`,{method:"POST",headers:{"content-type":"application/json",...t.headers},body:JSON.stringify(r),signal:a.signal});return await async function(e,n){const r=await e.text();if(!e.ok)throw new Error(`LangMem service ${n} failed with ${e.status}: ${r}`);return r?JSON.parse(r):{}}(o,n)}finally{clearTimeout(o)}}function n(e){return{namespace:e.namespace,query:e.query,limit:e.limit,kinds:e.kinds,records:[]}}

package/packages/memory/dist/src/maintenance.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryMaintenanceOperation, MemoryMaintenanceResult, RuntimeMemoryStore } from "./types.js";
+export declare function applyMemoryMaintenance(store: RuntimeMemoryStore, operations: MemoryMaintenanceOperation[]): Promise<MemoryMaintenanceResult[]>;

package/packages/memory/dist/src/maintenance.js

@@ -0,0 +1 @@
+export async function applyMemoryMaintenance(e,n){const t=[];for(const r of n)t.push(await a(e,r));return t}async function a(a,n){return"archive"===n.action?e(n,await a.archive(n.recordId,n.reason)):"mark_stale"===n.action?e(n,await a.update({id:n.recordId,status:"stale",metadata:{maintenanceReason:n.reason}})):"refresh"===n.action?e(n,await a.update({id:n.recordId,status:"active",metadata:{maintenanceReason:n.reason}})):e(n,await a.update({id:n.recordId,status:"archived",metadata:{maintenanceReason:n.reason,supersededBy:n.replacementRecordId}}))}function e(a,e){return{operation:a,record:e,applied:Boolean(e),reason:e?a.reason:"record not found"}}

package/packages/memory/dist/src/persistence.d.ts

@@ -0,0 +1,4 @@
+import type { ListMemoriesInput, MemoryPersistenceAdapter, MemoryRecord, MemoryStoreSnapshot, RuntimeMemoryStore } from "./types.js";
+export declare function createMemorySnapshot(store: RuntimeMemoryStore, input: ListMemoriesInput): Promise<MemoryStoreSnapshot>;
+export declare function createInMemoryMemoryPersistenceAdapter(): MemoryPersistenceAdapter;
+export declare function cloneRecords(records: MemoryRecord[]): MemoryRecord[];

package/packages/memory/dist/src/persistence.js

@@ -0,0 +1 @@
+export async function createMemorySnapshot(e,t){return{namespace:t.namespace,records:await e.list(t),exportedAt:(new Date).toISOString()}}export function createInMemoryMemoryPersistenceAdapter(){const e=new Map;return{load:async t=>cloneRecords(e.get(t)??[]),async save(t){e.set(t.namespace,cloneRecords(t.records))}}}export function cloneRecords(e){return e.map(e=>({...e,sourceRefs:[...e.sourceRefs],tags:[...e.tags],metadata:{...e.metadata},provenance:{...e.provenance},supersedes:[...e.supersedes],conflictsWith:[...e.conflictsWith]}))}

package/packages/memory/dist/src/policy.d.ts

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

package/packages/memory/dist/src/policy.js

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

package/packages/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/packages/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(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(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/packages/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/packages/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 d=e.policy??t(),m=n(e.records??[]);return{async submitCandidate(e){const t=d.decide(e);if("store"!==t.action)return{candidate:e,decision:t};const n=a({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 m.push(n),{candidate:e,decision:{...t,recordId:n.id},record:r(n)}},async memorize(e){const t=a(e);return m.push(t),r(t)},async recall(e){const t=e.query.toLowerCase(),n=s(m,e).filter(e=>function(e,t){return[e.canonicalKey,e.content,e.summary??"",...e.tags].join("\n").toLowerCase().includes(t)}(e,t)).sort(i).slice(0,e.limit??10);return{records:n,context:c(n)}},list:async e=>n(s(m,e)),async update(e){const t=m.find(t=>t.id===e.id);if(t)return function(e,t){e.content=t.content??e.content,e.summary=t.summary??e.summary,e.status=t.status??e.status,e.confidence=o(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),r(t)},async archive(e,t){const n=m.find(t=>t.id===e);if(n)return n.status="archived",n.metadata={...n.metadata,archiveReason:t},n.revision+=1,r(n)}}}function r(e){return n([e])[0]}function a(t){const n=(new Date).toISOString();return{id:e(),namespace:t.namespace,canonicalKey:(r=t.namespace,a=t.content,`${r}:${a.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:o(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,a}function s(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 i(e,t){return t.retrievalPriority-e.retrievalPriority||t.confidence-e.confidence||t.lastConfirmedAt.localeCompare(e.lastConfirmedAt)}function c(e){return e.map(e=>`- [${e.kind}/${e.scope}] ${e.summary??e.content}`).join("\n")}function o(e){return void 0===e||Number.isNaN(e)?.6:Math.min(1,Math.max(0,e))}

package/packages/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/packages/memory/dist/src/types.js

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

package/packages/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/packages/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("http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/packages/protocols/dist/src/http-server.js

@@ -0,0 +1 @@
+import{createServer as t}from"node:http";import{projectRuntimeTrace as e}from"@stable-harness/core";export function createHttpServer(o){return t(async(t,n)=>{try{if("GET"===t.method&&"/health"===t.url)return void r(n,200,{ok:!0});if("GET"===t.method&&"/inspect"===t.url)return void r(n,200,o.inspect());if("GET"===t.method&&"/requests"===t.url)return void r(n,200,o.listRequests());if("GET"===t.method&&"/sessions"===t.url)return void r(n,200,o.listSessions());const s=function(t){const e=(t??"").match(/^\/requests\/([^/]+)$/u);return e?.[1]?decodeURIComponent(e[1]):void 0}(t.url);if("GET"===t.method&&s){const t=o.inspectRequest(s);return void r(n,t?200:404,t??{error:"request_not_found"})}const i=function(t){const e=(t??"").match(/^\/runs\/([^/]+)\/trace$/u);return e?.[1]?decodeURIComponent(e[1]):void 0}(t.url);if("GET"===t.method&&i){const t=o.getRun(i);return void r(n,t?200:404,t?e(t):{error:"run_not_found"})}if("POST"===t.method&&"/requests"===t.url){const e=await async function(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),s="string"==typeof e.input?e.input:"",i="string"==typeof e.agentId?e.agentId:void 0,u=function(t){if("object"!=typeof t||null===t)return;const e=t;return"string"==typeof e.toolId?{toolId:e.toolId,args:e.args}:void 0}(e.toolCall);return void r(n,200,await o.request({input:s,agentId:i,toolCall:u}))}r(n,404,{error:"not_found"})}catch(t){r(n,500,{error:t instanceof Error?t.message:String(t)})}})}function r(t,e,r){t.writeHead(e,{"content-type":"application/json"}),t.end(JSON.stringify(r))}

package/packages/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/packages/protocols/dist/src/in-process-client.js

@@ -0,0 +1 @@
+export function createInProcessClient(e){return{request:s=>e.request(s),subscribe:s=>e.subscribe(s),inspect:()=>e.inspect(),getRun:s=>e.getRun(s),listRequests:s=>e.listRequests(s),listSessions:()=>e.listSessions(),inspectRequest:s=>e.inspectRequest(s),cancel:(s,t)=>e.cancel(s,t),stop:()=>e.stop()}}

package/packages/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/packages/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/packages/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("http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/packages/protocols/dist/src/openai-compatible.js

@@ -0,0 +1 @@
+import{createServer as e}from"node:http";import{randomUUID as t}from"node:crypto";export function createOpenAiCompatibleHttpServer(o,c={}){return e(async(e,p)=>{try{if(function(e,t,n){return"OPTIONS"===e.method&&(t.writeHead(204,l(n)),t.end(),!0)}(e,p,c))return;if(!function(e,t){return!t.bearerToken||e.headers.authorization===`Bearer ${t.bearerToken}`}(e,c))return void u(p,401,{error:{message:"unauthorized",type:"invalid_request_error"}},c);if("GET"===e.method&&"/v1/models"===e.url)return void u(p,200,function(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"}))}}(o,c),c);if("GET"===e.method&&"/v1/capabilities"===e.url)return void u(p,200,{object:"stable_harness.capabilities",endpoints:["/v1/models","/v1/chat/completions","/v1/capabilities"],streaming:!0,toolProgressEvents:!0},c);if("POST"===e.method&&"/v1/chat/completions"===e.url)return void await async function(e,o,c,p){const f=await async function(e){const t=[];for await(const n of e)t.push(Buffer.isBuffer(n)?n:Buffer.from(n));return 0===t.length?{}:JSON.parse(Buffer.concat(t).toString("utf8"))}(o);if(f.model&&!r(f.model,e,p))return void u(c,404,{error:{message:`model_not_found: ${f.model}`,type:"invalid_request_error"}},p);const m=function(e,o,s){const a=function(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"}: ${n(e.content)}`).join("\n\n")}(e.messages);return{input:a,requestId:`chatcmpl-${t()}`,agentId:r(e.model,o,s),metadata:{protocol:"openai-compatible",openaiStream:!0===e.stream,openaiMessages:(i=e.messages,Array.isArray(i)?i.map(e=>({role:e.role??"user",content:n(e.content)})):[]),model:e.model,user:e.user,clientMetadata:e.metadata}};var i}(f,e,p);f.stream?await async function(e,t,n,o,r){(function(e,t){e.writeHead(200,{"content-type":"text/event-stream","cache-control":"no-cache",connection:"keep-alive",...l(t)})})(t,r),d(t,a(o.requestId,n.model,{role:"assistant"},null));let i=!1;const c=e.subscribe(e=>{e.requestId===o.requestId&&(i=function(e,t,n,o){const r=function(e){if("adapter.event"!==e.type||"object"!=typeof e.event||null===e.event)return;const t=e.event;return"output.delta"===t.phase&&"string"==typeof t.text?t.text:void 0}(t);return r?(d(e,s(n,o,r)),!0):(function(e,t){const n=function(e){if("tool.started"===e.type||"tool.completed"===e.type)return{request_id:e.requestId,session_id:e.sessionId,agent_id:e.agentId,type:e.type,tool_id:e.toolId};if("adapter.event"!==e.type||"object"!=typeof e.event||null===e.event)return;const t=e.event,n="tool.start"===t.phase?"tool.started":"tool.result"===t.phase?"tool.completed":void 0,o="string"==typeof t.toolId?t.toolId:void 0;return n&&o?{request_id:e.requestId,session_id:e.sessionId,agent_id:e.agentId,type:n,tool_id:o,adapter:t.adapter}:void 0}(t);n&&function(e,t,n){e.write("event: stable_harness.tool.progress\n"),e.write(`data: ${JSON.stringify(n)}\n\n`)}(e,0,n)}(e,t),!1)}(t,e,o.requestId,n.model)||i)});try{const r=await e.request(o);i||d(t,s(o.requestId,n.model,r.output)),d(t,function(e,t){return a(e,t,{},"stop")}(o.requestId,n.model)),t.write("data: [DONE]\n\n"),t.end()}finally{c()}}(e,c,f,m,p):u(c,200,function(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:i(e.messages,t.output),metadata:{sessionId:t.sessionId,agentId:t.agentId,state:t.state}}}(f,await e.request(m)),p)}(o,e,p,c);u(p,404,{error:{message:"not_found",type:"invalid_request_error"}},c)}catch(e){u(p,400,{error:{message:e instanceof Error?e.message:String(e),type:"invalid_request_error"}},c)}})}function n(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(o).join("\n")}function o(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 r(e,t,n){if(!e)return;const o=n.modelAgentMap?.[e];return o||(t.inspect().agents.includes(e)?e:void 0)}function s(e,t,n){return a(e,t,{content:n},null)}function a(e,t,n,o){return{id:e,object:"chat.completion.chunk",created:Math.floor(Date.now()/1e3),model:t??"stable-harness",choices:[{index:0,delta:n,finish_reason:o}]}}function i(e,t){const o=c(Array.isArray(e)?e.map(e=>n(e.content)).join("\n"):""),r=c(t);return{prompt_tokens:o,completion_tokens:r,total_tokens:o+r}}function c(e){return e.trim()?Math.ceil(1.3*e.trim().split(/\s+/u).length):0}function u(e,t,n,o){e.writeHead(t,{"content-type":"application/json",...l(o)}),e.end(JSON.stringify(n))}function d(e,t){e.write(`data: ${JSON.stringify(t)}\n\n`)}function l(e){return e.corsOrigins?.length?{"access-control-allow-origin":e.corsOrigins.join(", "),"access-control-allow-headers":"authorization, content-type, idempotency-key","access-control-allow-methods":"GET, POST, OPTIONS"}:{}}

package/packages/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",
+  "dependencies": {
+    "@stable-harness/core": "0.0.1"
+  }
+}

package/packages/tool-gateway/dist/src/argument-guard.d.ts

@@ -0,0 +1,32 @@
+import type { BetterToolLike, RepairFunction, RepairModelLike } 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;
+};
+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/packages/tool-gateway/dist/src/argument-guard.js

@@ -0,0 +1 @@
+import{BetterToolValidationError as e,betterTools as t,defaultRepair as r,reliableToolCalls as o}from"@botbotgo/better-call";export class ToolArgumentValidationError extends Error{toolId;issues;constructor(e,t){super(`Tool argument validation failed for ${e}: ${t.map(e=>`${e.path} ${e.message}`).join("; ")}`),this.toolId=e,this.issues=t,this.name="ToolArgumentValidationError"}}export function createDefaultArgumentGuard(t={}){return{async validate(r){const o=r.tool.validateArgs?await r.tool.validateArgs({args:r.args,context:r.context}):{action:"allow",args:r.args};if("reject"===o.action)return o;const n=await async function(t,r,o){const n=function(e,t){return d(e.schema)?a(e.schema.safeParse(t??{})):u(r=e.schema)&&Object.values(r).length>0&&Object.values(r).every(d)?function(e,t){const r=u(t)?t:{},o={},s=[];for(const[t,a]of Object.entries(e)){const e=a.safeParse(r[t]);e.success?void 0!==e.data&&(o[t]=e.data):s.push(...e.error.issues.map(e=>({...e,path:[t,...e.path]})))}return s.length>0?a({success:!1,error:{issues:s}}):{action:"allow",args:o}}(e.schema,t):void 0;var r}(t,r);return n||(u(t.schema)?async function(t,r,o){try{return{action:"allow",args:await s(t,o).invoke(r)}}catch(t){if(t instanceof e)return{action:"reject",reason:"BetterCall validation failed",issues:t.issues.map(c)};throw t}}(t,r,o):{action:"allow",args:r})}(r.tool,o.args,t.betterCall);return"reject"===n.action?n:"repair"===o.action?{...o,args:n.args}:n}}}export function assertToolArguments(e,t,r,o){return Promise.resolve(o.validate({tool:e,args:t,context:r})).then(t=>{if("reject"===t.action)throw new ToolArgumentValidationError(e.id,t.issues);return t.args})}function a(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})}}export function prepareBetterCallTools(e,r){const o=t(e.map(n),l(r));return e.map((e,t)=>({...e,validationTool:o[t]}))}export async function repairBetterCallToolSelection(e){const t=(a=e.options,a?.repair??(a?.repairModel?r(a.repairModel):void 0));var a;if(!t||0===e.tools.length)return;const s=await o({userInput:JSON.stringify({tool:e.toolId,args:e.args}),tools:e.tools.map(i),calls:[{tool:e.toolId,args:(n=e.args,u(n)?n:{input:n})}],repair:t,mode:e.options?.mode??"repair"});var n;const c=s.ok?s.calls.find(t=>e.tools.some(e=>e.id===t.tool)):void 0;return c?{toolId:c.tool,args:c.args}:void 0}function s(e,r){return e.validationTool??t([n(e)],l(r))[0]}function n(e){return{name:e.id,description:e.description,schema:e.schema,invoke:e=>e}}function i(e){return{name:e.id,description:e.description,schema:u(e.schema)?e.schema:void 0}}function c(e){return{path:e.path.replace(/^\$\.calls\[\d+\]\.args/u,"$"),message:e.message,expected:void 0===e.expected?void 0:String(e.expected),actual:e.actual}}function l(e){return{mode:e?.mode??"repair",repair:e?.repair,repairModel:e?.repairModel}}function u(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function d(e){return u(e)&&"function"==typeof e.safeParse}

package/packages/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/packages/tool-gateway/dist/src/in-memory.js

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

package/packages/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/packages/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/packages/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/packages/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 r(t);o&&e.push(o)}return t(e,o.options)}async function r(t){if(!t.sourcePath)return;const r=await import(e(o.resolve(t.sourcePath)).href),n=r[t.name??t.id]??r.default;var i;return"object"==typeof(i=n)&&null!==i&&"invoke"in i&&"function"==typeof i.invoke?{id:t.id,description:t.description??n.description,schema:t.schema??n.schema,validateArgs:n.validateArgs,invoke:(o,e)=>async function(o,e,t){const r=process.cwd();try{return process.chdir(t.workspaceRoot),await o(e)}finally{process.chdir(r)}}(n.invoke,o,e)}:void 0}

package/packages/tool-gateway/dist/src/types.d.ts

@@ -0,0 +1,65 @@
+export type ToolGatewayContext = {
+    workspaceRoot: string;
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+};
+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;
+    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/packages/tool-gateway/dist/src/types.js

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

package/packages/tool-gateway/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@stable-harness/tool-gateway",
+  "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",
+  "dependencies": {
+    "@botbotgo/better-call": "^0.1.1"
+  }
+}