stable-harness 0.0.37 → 0.0.38

package/node_modules/@stable-harness/adapter-deepagents/dist/src/adapter.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeAdapter } from "@stable-harness/core";
+import type { DeepAgentFactory, DeepAgentsAdapterRunner } from "./types.js";
+type DeepAgentsAdapterOptions = {
+    runner?: DeepAgentsAdapterRunner;
+    createDeepAgent?: DeepAgentFactory;
+    config?: Record<string, unknown>;
+};
+export declare function createDeepAgentsAdapter(options?: DeepAgentsAdapterOptions): RuntimeAdapter;
+export {};

package/node_modules/@stable-harness/adapter-deepagents/dist/src/adapter.js

@@ -0,0 +1 @@
+import{realpathSync as e}from"node:fs";import t from"node:path";import{createBuiltinToolPolicyMiddleware as r,createObserverMiddleware as n,resolveFilesystemPermissions as o}from"./internal/builtin-tool-policy.js";import{buildGatewayTools as s,createToolRepeatState as a,stringifyDeepAgentResult as i}from"./internal/gateway-tools.js";import{resolveDeepAgentsNativeMemories as l}from"./memory.js";import{buildDeepAgentRequest as d}from"./internal/messages.js";import{createRawToolCallParserMiddleware as c}from"./internal/raw-tool-call-parser.js";import{createBackendModel as p}from"./model-providers.js";import{createDeepAgentsRetryMiddleware as u}from"./retry-policy.js";import{streamDeepAgentResult as g}from"./internal/stream-events.js";export function createDeepAgentsAdapter(e={}){return{name:"deepagents",canRun:e=>"deepagents"===e.backend,async run(t){if(t.emit({type:"runtime.adapter.event",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,event:{adapter:"deepagents",phase:"agent.handoff",modelRef:t.agent.modelRef,tools:t.agent.tools,subagents:t.agent.subagents}}),e.runner)return e.runner(t);const r=e.createDeepAgent?void 0:await async function loadDeepAgentsModule(){try{return await async function importOptionalPackage(e){return import(e)}("deepagents")}catch(e){throw new Error(`DeepAgents package is required for the default adapter path: ${function formatError(e){return e instanceof Error?e.message:String(e)}(e)}`)}}(),n=e.createDeepAgent??function readCreateDeepAgent(e){const t=e?.createDeepAgent;if("function"==typeof t)return t;throw new Error("DeepAgents package does not export createDeepAgent.")}(r),a=n(function buildDeepAgentParams(e,t,r){const n={...readDeepAgentsConfig(t),...readDeepAgentsConfig(e.agent.config.deepagents)},a=resolveDeepAgentsSkills(e,e.agent),i=n.permissions??o(e,e.agent),l=requestScopedRepeatState(e,e.agent.id);return pruneUndefined({name:e.agent.id,model:n.model??resolveAgentModel(e,e.agent),systemPrompt:buildSystemPrompt(e,e.agent),backend:n.backend??resolveDeepAgentsBackend(e,r,a),checkpointer:n.checkpointer,store:n.store,middleware:mergeMiddleware(e,e.agent,n.middleware,l),responseFormat:n.responseFormat,contextSchema:n.contextSchema,interruptOn:n.interruptOn,generalPurposeAgent:readBoolean(n.generalPurposeAgent),taskDescription:readString(n.taskDescription),permissions:i,tools:s(e,e.agent.id,e.agent.tools,resolveAgentRepairModel(e,e.agent,n),l),subagents:e.agent.subagents.map(t=>{const r=e.workspace.agents.get(t),n=readDeepAgentsConfig(r?.config.deepagents),a=n.permissions??o(e,r),i=scopedInput(e,r),l=requestScopedRepeatState(e,t);return pruneUndefined({name:t,description:r?.description??readString(r?.config.description)??r?.id,systemPrompt:buildSystemPrompt(e,r),model:n.model??(r?resolveAgentModel(e,r):void 0),middleware:mergeMiddleware(i,r,n.middleware,l),interruptOn:n.interruptOn,generalPurposeAgent:readBoolean(n.generalPurposeAgent),taskDescription:readString(n.taskDescription),permissions:a,responseFormat:n.responseFormat,tools:s(e,t,r?.tools??[],resolveAgentRepairModel(i,r,n),l),memory:resolveDeepAgentsMemory(e,r),skills:resolveDeepAgentsSkills(e,r)})}),memory:resolveDeepAgentsMemory(e,e.agent),skills:a})}(t,e.config,r)),l=d(t),c=function buildDeepAgentInvokeConfig(e){return pruneUndefined({recursionLimit:readNumber(readDeepAgentsConfig(e.config.deepagents).recursionLimit)??readNumber(e.config.recursionLimit)})}(t.agent);if(!0===t.request.metadata?.openaiStream&&a.streamEvents)return g(t,a.streamEvents(l,{version:"v2",...c}),i);const p=await a.invoke(l,c);return i(p)}}}function buildSystemPrompt(e,t){const r=t?.systemPrompt??readString(t?.config.systemPrompt),n=function buildSkillInventoryPolicy(e,t){const r=(t?.skills??[]).map(t=>e.workspace.skills.get(t)).filter(e=>Boolean(e));if(0!==r.length)return["## Stable Harness Skill Inventory","Use only the skills listed in this workspace inventory. Do not infer or invent skill names, skill directories, or SKILL.md paths from generic examples.","Skill files are already registered with the backend. Do not read local SKILL.md files or skill directories through filesystem tools.","If none of these skills match the task, continue with the configured tools and collected evidence instead of reading an unlisted skill path.",r.map(e=>{const t=e.allowedTools.length>0?`; allowed tools: ${e.allowedTools.join(", ")}`:"",r=e.description?`: ${e.description}${t}`:t;return`- ${e.id}${r}`}).join("\n")].join("\n")}(e,t),o=function buildResponseLanguagePolicy(e){const t=isRecord(e.workspace.runtime.responseLanguage)?e.workspace.runtime.responseLanguage:{};if("matchUser"!==(readString(t.mode)??readString(t.strategy)))return;const r=function detectRequestLanguage(e){return/\p{Script=Han}/u.test(e)?"Chinese":/[\p{Script=Hiragana}\p{Script=Katakana}]/u.test(e)?"Japanese":/\p{Script=Hangul}/u.test(e)?"Korean":/\p{Script=Arabic}/u.test(e)?"Arabic":/\p{Script=Hebrew}/u.test(e)?"Hebrew":/\p{Script=Thai}/u.test(e)?"Thai":/\p{Script=Cyrillic}/u.test(e)?"Cyrillic-script language":void 0}(e.request.input);return["Stable runtime response language policy:",...r?[`- Detected request language: ${r}.`]:[],"- Match the final answer language to the original user request unless the user explicitly asks for another language.","- If tool or subagent evidence is in a different language, translate the final user-facing answer into the detected request language.","- When delegating to subagents, include the same response-language requirement in delegated instructions.","- Do not call another tool or subagent only to translate, rewrite, format, or synthesize a completed answer.",`Original user request:\n${e.request.input}`].join("\n")}(e),s=function buildResponsePresentationPolicy(e,t){const r=isRecord(e.workspace.runtime.responsePresentation)?e.workspace.runtime.responsePresentation:{};if(!0===r.enabled&&!function hasStructuredResponseFormat(e){return void 0!==e?.config.responseFormat||isRecord(e?.config.deepagents)&&void 0!==e.config.deepagents.responseFormat}(t)&&"markdown"===(readString(r.style)??"markdown"))return["Stable runtime final-answer presentation policy:","- For user-facing natural-language final answers, use GitHub-flavored Markdown.","- Prefer clear section headings, short paragraphs, and concise bullets over dense prose.","- Use tables only when they make comparison or planning details easier to scan.","- For detailed investigations, plans, or reports, include assumptions, findings, recommendations, and concrete next steps.","- Preserve exact plain text, JSON, code, or other structured output when the user or response format asks for it.","- Do not end with generic follow-up offers; deliver the requested answer directly."].join("\n")}(e,t);return[r,n,o,s].filter(Boolean).join("\n\n")||void 0}function resolveDeepAgentsMemory(e,t){const r=readDeepAgentsStringArray(t?.config,"memory");if(r)return r;const n=l(e.workspace).map(e=>`/memories/${e.id}.md`);return n.length>0?n:void 0}function resolveDeepAgentsSkills(r,n){const o=readDeepAgentsStringArray(n?.config,"skills");if(o)return o;const s=[...new Set((n?.skills??[]).map(e=>r.workspace.skills.get(e)?.path).filter(e=>"string"==typeof e&&e.trim().length>0).map(n=>function backendSkillSourcePath(r,n){const o=t.dirname(t.dirname(n)),s=t.relative(r,o);return!s||s.startsWith("..")||t.isAbsolute(s)?""===s?"/":function canonicalPath(t){try{return e.native(t)}catch{return t}}(o):`/${s.split(t.sep).join("/")}`}(r.workspace.root,n)))];return s.length>0?s:void 0}function resolveDeepAgentsBackend(e,t,r){if(t?.FilesystemBackend&&r&&0!==r.length)return()=>new t.FilesystemBackend({rootDir:e.workspace.root})}function mergeMiddleware(e,t,o,s=a(e.workspace.runtime.toolGateway)){const i=Array.isArray(o)?o:[],l=scopedInput(e,t),d=new Set;return[n(l,{observedToolIds:d,repeatState:s}),r(l,{repeatState:s}),...u(e.workspace.runtime.retry),...i,c(l)]}function requestScopedRepeatState(e,t){const r=`deepagents.repeat.${t}`,n=e.requestState?.get(r);if(n)return n;const o=a(e.workspace.runtime.toolGateway);return e.requestState&&o&&e.requestState.set(r,o),o}function scopedInput(e,t){return t?{...e,agent:t}:e}function resolveAgentModel(e,t){const r=t.modelRef?e.workspace.models.get(t.modelRef):void 0;return r?p(r):void 0}function resolveAgentRepairModel(e,t,r){const n=r.model;if(isRepairModel(n))return n;if(!t)return;const o=resolveAgentModel(e,t);return isRepairModel(o)?o:void 0}function readDeepAgentsConfig(e){return isRecord(e)?e:{}}function readDeepAgentsStringArray(e,t){const r=isRecord(e)?e:{},n=readDeepAgentsConfig(r.deepagents),o="memory"===t?["memory","memorySources"]:["skills","skillSources"];for(const e of o){const t=readStringArray(n[e]);if(t)return t}return readStringArray(r[t])}function pruneUndefined(e){return Object.fromEntries(Object.entries(e).filter(([,e])=>void 0!==e))}function readString(e){return"string"==typeof e&&e.trim()?e:void 0}function readNumber(e){return"number"==typeof e&&Number.isFinite(e)?e:void 0}function readBoolean(e){return"boolean"==typeof e?e:void 0}function readStringArray(e){return Array.isArray(e)?e.filter(e=>"string"==typeof e):void 0}function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function isRepairModel(e){return"object"==typeof e&&null!==e&&"invoke"in e&&"function"==typeof e.invoke}

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

@@ -0,0 +1,4 @@
+export { createDeepAgentsAdapter } from "./adapter.js";
+export { createDeepAgentsMemoryMaintenanceTarget, resolveDeepAgentsNativeMemories } from "./memory.js";
+export { createBackendModel } from "./model-providers.js";
+export type { DeepAgentFactory, DeepAgentsAdapterRunner } from "./types.js";

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

@@ -0,0 +1 @@
+export{createDeepAgentsAdapter}from"./adapter.js";export{createDeepAgentsMemoryMaintenanceTarget,resolveDeepAgentsNativeMemories}from"./memory.js";export{createBackendModel}from"./model-providers.js";

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/builtin-args.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeArgsRecord(args: unknown): Record<string, unknown>;
+export declare function normalizeWriteTodosArgs(args: unknown): Record<string, unknown>;
+export declare function normalizeFilesystemArgs(toolId: string, args: unknown, workspaceRoot: string): Record<string, unknown>;
+export declare function normalizeExecuteArgs(args: unknown, workspaceRoot: string): Record<string, unknown>;
+export declare function shallowEqualRecord(left: Record<string, unknown>, right: Record<string, unknown>): boolean;

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/builtin-args.js

@@ -0,0 +1 @@
+import t from"node:path";export function normalizeArgsRecord(t){if(isRecord(t))return t;if("string"!=typeof t||!t.trim())return{};try{const r=JSON.parse(t);return isRecord(r)?r:{}}catch{return{}}}export function normalizeWriteTodosArgs(t){if(Array.isArray(t))return{todos:t.map(normalizeTodoItem)};if("string"==typeof t&&t.trim())try{const r=JSON.parse(t);if(Array.isArray(r))return{todos:r.map(normalizeTodoItem)}}catch{return{todos:[{content:t.trim()}]}}const r=normalizeArgsRecord(t),e=readTodoList(r);return e?{...r,todos:e.map(normalizeTodoItem)}:r}export function normalizeFilesystemArgs(t,r,e){const i={...normalizeArgsRecord(r)};return copyFirstStringAlias(i,"path",function filesystemPathAliases(t){return"grep"===t?["file","filename","filepath","filePath","directory","dir"]:["file_path","file","filename","filepath","filePath","target","directory","dir"]}(t)),copyFirstStringAlias(i,"pattern",function filesystemPatternAliases(t){return"glob"!==t?[]:["query","regex","search"]}(t)),copyFirstStringAlias(i,"content","write_file"===t?["text","body"]:[]),copyFirstStringAlias(i,"old_string","edit_file"===t?["oldText","old","replace","from"]:[]),copyFirstStringAlias(i,"new_string","edit_file"===t?["newText","new","with","to"]:[]),normalizePathField(i,e,"path"),normalizePathField(i,e,"file_path"),normalizePathField(i,e,"pattern","glob"===t),i}export function normalizeExecuteArgs(t,r){const e={...normalizeArgsRecord(t)};return copyFirstStringAlias(e,"command",["cmd","shell","input"]),normalizePathField(e,r,"cwd"),e}export function shallowEqualRecord(t,r){const e=Object.keys(t),i=Object.keys(r);return e.length===i.length&&e.every(e=>t[e]===r[e])}function readTodoList(t){const r=t.todos??t.items??t.tasks??t.plan;if(Array.isArray(r))return r;if(isRecord(r))return readTodoList(r)??[r];if("string"==typeof r&&r.trim())try{const t=JSON.parse(r);return Array.isArray(t)?t:isRecord(t)?readTodoList(t):void 0}catch{return}}function normalizeTodoItem(t){if("string"==typeof t&&t.trim())return{content:t.trim()};if(!isRecord(t))return t;const r=readString(t.content)??readString(t.description)??readString(t.task)??readString(t.step)??readString(t.gap)??readString(t.evidenceGap)??readString(t.evidence_gap)??readString(t.action)??readString(t.title)??readString(t.name),e=function normalizeTodoStatus(t){if(!t)return;const r=t.toLowerCase().replaceAll("-","_").replaceAll(" ","_");return"todo"===r||"not_started"===r||"planned"===r||"blocked"===r?"pending":"doing"===r||"in_progress"===r||"partial"===r?"in_progress":"done"===r||"complete"===r||"filled"===r?"completed":r}(readString(t.status)??readString(t.state));return{...r?{content:r}:{},...e?{status:e}:{}}}function readString(t){return"string"==typeof t&&t.trim()?t.trim():void 0}function copyFirstStringAlias(t,r,e){if(!readString(t[r]))for(const i of e){const e=readString(t[i]);if(e)return void(t[r]=e)}}function normalizePathField(r,e,i,n=!0){const o=n?readString(r[i]):void 0;o&&(r[i]=function workspaceBackendPath(r,e){if(!e.startsWith("/"))return e;if(function isPathInside(r,e){const i=t.relative(r,e);return""===i||!!i&&!i.startsWith("..")&&!t.isAbsolute(i)}(r,e)){const i=t.relative(r,e).split(t.sep).filter(Boolean).join("/");return i?`/${i}`:"/"}return e}(e,o))}function isRecord(t){return"object"==typeof t&&null!==t&&!Array.isArray(t)}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/builtin-call-repair.d.ts

@@ -0,0 +1,9 @@
+export declare function repairBuiltinToolRequest<T extends {
+    toolCall?: {
+        args?: unknown;
+    };
+}>(input: {
+    toolId: string;
+    request: T;
+    workspaceRoot: string;
+}): Promise<T>;

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/builtin-call-repair.js

@@ -0,0 +1 @@
+import{repairCallSelection as t}from"@botbotgo/better-call";import{normalizeArgsRecord as e,normalizeExecuteArgs as r,normalizeFilesystemArgs as o,normalizeWriteTodosArgs as i,shallowEqualRecord as s}from"./builtin-args.js";const a=new Set(["ls","read_file","write_file","edit_file","glob","grep"]);export async function repairBuiltinToolRequest(e){const r=normalizeBuiltinArgs(e.toolId,e.request.toolCall?.args,e.workspaceRoot),o=function builtinCandidate(t){const e=n[t];return e?{id:t,description:`DeepAgents builtin tool ${t}`,schema:e}:void 0}(e.toolId);if(!o)return updateRequestArgs(e.request,e.request.toolCall?.args,r);const i=await t({call:{id:e.toolId,args:r},candidates:[o],mode:"repair"}),s=i.ok?normalizeBuiltinArgs(e.toolId,i.args,e.workspaceRoot):r;return updateRequestArgs(e.request,e.request.toolCall?.args,s)}function normalizeBuiltinArgs(t,s,n){return"write_todos"===t?i(s):"read_todos"===t||"task"===t?e(s):"execute"===t?r(s,n):a.has(t)?o(t,s,n):e(s)}function updateRequestArgs(t,e,r){return function isRecord(t){return"object"==typeof t&&null!==t&&!Array.isArray(t)}(e)&&s(e,r)?t:{...t,toolCall:{...t.toolCall,args:r}}}const n={write_todos:objectSchema({todos:{type:"array",items:{type:"object",additionalProperties:!0}}}),read_todos:objectSchema({}),task:objectSchema({subagent_type:{type:"string"},subagentType:{type:"string"},description:{type:"string"},task:{type:"string"}}),execute:objectSchema({command:{type:"string"},cwd:{type:"string"},timeoutMs:{type:"number"}}),ls:objectSchema({path:{type:"string"}}),read_file:objectSchema({path:{type:"string"},file_path:{type:"string"}}),write_file:objectSchema({path:{type:"string"},file_path:{type:"string"},content:{type:"string"}}),edit_file:objectSchema({path:{type:"string"},file_path:{type:"string"},old_string:{type:"string"},new_string:{type:"string"}}),glob:objectSchema({path:{type:"string"},pattern:{type:"string"}}),grep:objectSchema({path:{type:"string"},pattern:{type:"string"}})};function objectSchema(t){return{type:"object",properties:t,additionalProperties:!0}}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/builtin-tool-policy.d.ts

@@ -0,0 +1,39 @@
+import { ToolMessage } from "@langchain/core/messages";
+import type { RuntimeAdapter, WorkspaceAgent } from "@stable-harness/core";
+import { type ToolRepeatState } from "./gateway-tools.js";
+type AdapterRunInput = Parameters<RuntimeAdapter["run"]>[0];
+export declare function createBuiltinToolPolicyMiddleware(input: AdapterRunInput, options?: {
+    repeatState?: ToolRepeatState;
+}): {
+    name: string;
+    wrapModelCall(request: {
+        tools?: Array<{
+            name?: unknown;
+        }>;
+        toolChoice?: unknown;
+    }, handler: (request: unknown) => Promise<unknown>): Promise<unknown>;
+};
+export declare function validateFilesystemBuiltinCall(input: AdapterRunInput, toolId: string, request: {
+    toolCall?: {
+        id?: string;
+    };
+}): ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>> | undefined;
+export declare function createObserverMiddleware(input: AdapterRunInput, options?: {
+    observedToolIds?: Set<string>;
+    repeatState?: ToolRepeatState;
+}): {
+    name: string;
+    wrapToolCall(request: {
+        toolCall?: {
+            id?: string;
+            name?: string;
+            args?: unknown;
+        };
+    }, handler: (request: unknown) => Promise<unknown>): Promise<unknown>;
+};
+export declare function resolveFilesystemPermissions(input: AdapterRunInput, agent: WorkspaceAgent | undefined): {
+    operations: string[];
+    paths: string[];
+    mode: string;
+}[] | undefined;
+export {};

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/builtin-tool-policy.js

@@ -0,0 +1 @@
+import{realpathSync as e}from"node:fs";import{repairCallSelection as t}from"@botbotgo/better-call";import{ToolMessage as o}from"@langchain/core/messages";import{normalizeArgsRecord as n}from"./builtin-args.js";import{repairBuiltinToolRequest as r}from"./builtin-call-repair.js";import{afterToolInvoke as i,beforeToolInvoke as a,createToolRepeatState as s,stringifyDeepAgentResult as l,toolControlProjection as u}from"./gateway-tools.js";import{observedToolEvidence as d,recordObservedToolEvidence as c}from"./gateway/tool-evidence.js";import{validateSkillFileBuiltinCall as p}from"./skill-file-policy.js";import{filterRepeatLimitedTools as g}from"./tool-repeat-visibility.js";import{traceProjectionForBuiltinTool as f}from"./trace-projection.js";const m=new Set(["ls","read_file","write_file","edit_file","glob","grep"]),h=new Set(["write_todos","read_todos","task","execute",...m]);export function createBuiltinToolPolicyMiddleware(e,t={}){return{name:"StableHarnessBuiltinToolPolicy",async wrapModelCall(o,n){const r=Array.isArray(o.tools)?g(o.tools.filter(t=>!function hasHiddenBuiltins(e){return isFilesystemDisabled(e)||!isTaskVisible(e)}(e)||isModelVisibleBuiltin(e,t.name)),t.repeatState):o.tools,i=function normalizeToolChoice(e,t,o){return"required"===t?o&&o.length>0?t:"auto":function isForcedHiddenTool(e,t){return"string"==typeof t?.function?.name&&!isModelVisibleBuiltin(e,t.function.name)}(e,t)?"auto":t}(e,o.toolChoice,r);return n({...o,tools:r,toolChoice:i})}}}export function validateFilesystemBuiltinCall(e,t,n){if(isFilesystemDisabled(e)&&m.has(t))return new o({tool_call_id:n.toolCall?.id??`stable-harness-${t}-policy`,name:t,content:`Filesystem builtin tool '${t}' is disabled for this agent. Do not retry filesystem tools; use the agent's registered workspace tools and already collected evidence instead.`})}export function createObserverMiddleware(e,u={}){const c=u.repeatState??s(e.workspace.runtime.toolGateway);return{name:"StableHarnessObserver",async wrapToolCall(s,g){const f=s.toolCall?.name;if(!f||!h.has(f))return g(s);const m=await r({toolId:f,request:s,workspaceRoot:e.workspace.root});emitToolEvent(e,f,"agent.tool.start",m.toolCall?.args);const y="task"===f?await async function repairTaskCall(e,r){const i=function allowedTaskTypes(e){const t=readConfigRecord(e.agent.config,"deepagents");if(!0===t?.generalPurposeAgent)return;const o=readConfigRecord(e.agent.config,"builtinTools")?.modelExposed;return!1===o?[]:Array.isArray(o)?o.includes("task")?e.agent.subagents:[]:0===e.agent.subagents.length?[]:void 0}(e);if(void 0===i)return{request:r};const a=n(r.toolCall?.args),s=function readTaskSubagentType(e){const t=isRecord(e)?e:{};return readString(t.subagent_type)??readString(t.subagentType)}(a);if(s&&i.includes(s))return{request:r};const l=await t({call:{id:s,args:a},candidates:taskCallCandidates(e,i),mode:"repair"});if(l.ok){emitInventoryRepair(e,"repaired",s,l.candidateId,i);const t={...a,...l.args,subagent_type:l.candidateId};return{request:{...r,toolCall:{...r.toolCall,args:t}}}}emitInventoryRepair(e,"blocked",s,void 0,i,l.reason);const u=s?`: ${s}`:"",d=i.length>0?i.join(", "):"none";return{request:r,blocked:new o({tool_call_id:r.toolCall?.id??"stable-harness-task-policy",name:"task",status:"error",content:[`Task delegation target is not in the workspace inventory${u}. Allowed task targets: ${d}.`,"Retry with an allowed target only when that target semantically owns the original user request.","Do not substitute another specialist just to continue the same evidence need; synthesize from already collected evidence when no allowed target is a semantic match."].join(" ")})}}(e,m):{request:m},v=y.request,b=y.blocked;if(b)return emitToolEvent(e,f,"agent.tool.result",v.toolCall?.args,{output:b.content}),b;const k=validateFilesystemBuiltinCall(e,f,v);if(k)return emitToolEvent(e,f,"agent.tool.result",v.toolCall?.args,{output:k.content}),k;const w=p(e,f,v);if(w)return emitToolEvent(e,f,"agent.tool.result",v.toolCall?.args,{output:w.content}),w;try{const t=c?a(f,v.toolCall?.args,c):void 0;if(t)return emitToolEvent(e,f,"agent.tool.result",v.toolCall?.args,{output:t.eventOutput}),builtinToolMessage(s,f,function modelOutputForRepeatedBuiltin(e,t){return"task"!==e?t:function readPreviousOutput(e){try{const t=JSON.parse(e);if(!isRecord(t)||"repeated_tool_call_limit"!==t.status||"string"!=typeof t.previousOutput)return;const o=t.previousOutput.trim();return o.length>0?o:void 0}catch{return}}(t)??t}(f,t.modelOutput));const o=await g(v),n=function observedToolOutput(e,t,o){return"write_todos"===e?JSON.stringify({status:"recorded",args:t.toolCall?.args}):l(o)}(f,v,o),r=c?i(f,v.toolCall?.args,n,o,c):{};return emitToolEvent(e,f,"agent.tool.result",v.toolCall?.args,{output:r.eventOutput??n}),u.observedToolIds?.add(f),void 0===r.modelOutput?o:builtinToolMessage(s,f,r.modelOutput)}catch(t){const n=function recoverableBuiltinToolError(e,t,n,r){const i=formatError(r);if("task"===t&&/repeat limit reached for tool/iu.test(i)){const t=function formatObservedEvidence(e){const t=d(e);if(0===t.length)return"";const o=t.map(e=>[`Agent: ${e.agentId}`,`Tool: ${e.toolId}`,e.output].join("\n")).join("\n\n---\n\n");return o.length>12e3?`${o.slice(0,12e3)}\n[truncated]`:o}(e);return new o({tool_call_id:n.toolCall?.id??"stable-harness-task-repeat-limit",name:"task",content:JSON.stringify({status:"delegated_task_repeat_limit",finalizationRequired:!0,instruction:"The delegated agent reached a configured tool repeat limit. Stop delegating this evidence need and do not send a synthesis task to another subagent for the same need. Finalize only from observedEvidence and other evidence that is already visible in this run. If the visible evidence is insufficient for a requested claim, report an explicit blocker or evidence gap instead of estimating, inventing, or using generic knowledge.",...t?{observedEvidence:t}:{},error:previewError(i)})})}if(/Received tool input did not match expected schema|Invalid input:/iu.test(i))return new o({tool_call_id:n.toolCall?.id??`stable-harness-${t}-argument-error`,name:t,status:"error",content:JSON.stringify({status:"tool_argument_error",toolId:t,instruction:"The upstream builtin tool rejected these arguments. Fix the tool arguments according to the tool schema, or choose a more appropriate available tool.",error:previewError(i)})})}(e,f,s,t);if(n)return emitToolEvent(e,f,"agent.tool.result",m.toolCall?.args,{output:n.content}),n;throw emitToolEvent(e,f,"agent.tool.result",m.toolCall?.args,{error:formatError(t)}),t}}}}function builtinToolMessage(e,t,n){return new o({tool_call_id:e.toolCall?.id??`stable-harness-${t}-repeat-guard`,name:t,content:n})}export function resolveFilesystemPermissions(e,t){const o=readConfigRecord(t?.config,"builtinTools"),n=[];if(n.push(...function skillReadPermissions(e,t){const o=[...new Set((t?.skills??[]).flatMap(t=>function skillReadPaths(e,t){return t?[...new Set([t,canonicalPath(t),backendSkillPath(e,t)])].flatMap(e=>function skillReadPathCandidates(e){const t=e.replace(/\/+$/u,""),o=t.endsWith("/SKILL.md")?t.slice(0,-9):t,n=function parentPath(e){const t=e.lastIndexOf("/");return t>0?e.slice(0,t):void 0}(o);return[t,o,`${o}/**`,...n?[n,`${n}/**`]:[]]}(e)):[]}(e.workspace.root,e.workspace.skills.get(t)?.path)).filter(e=>e.startsWith("/")))];return o.length>0?[{operations:["read"],paths:o,mode:"allow"}]:[]}(e,t)),!1!==o?.filesystem){if(deepagentsMemoryWritable(e))return n.length>0?n:void 0}else n.push({operations:["read"],paths:["/memories/**"],mode:"allow"}),n.push({operations:["read","write"],paths:["/**"],mode:"deny"});return deepagentsMemoryWritable(e)||n.push({operations:["write"],paths:["/memories/**"],mode:"deny"}),n.length>0?n:void 0}function emitToolEvent(e,t,o,n,r={}){"string"==typeof r.output&&c(e,e.agent.id,t,r.output),e.emit({type:"runtime.adapter.event",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,event:{adapter:"deepagents",phase:o,toolId:t,..."agent.tool.start"===o?{args:n}:{},...r,..."string"==typeof r.output?u(r.output):{},...f(t,o,n)}})}function backendSkillPath(e,t){const o=function pathRelative(e,t){const o=e.split("/").filter(Boolean),n=t.split("/").filter(Boolean);if(!(n.length<o.length)){for(let e=0;e<o.length;e+=1)if(o[e]!==n[e])return;return n.slice(o.length).join("/")}}(e,t);return void 0===o?t:`/${o.split("/").filter(Boolean).join("/")}`}function canonicalPath(t){try{return e.native(t)}catch{return t}}function deepagentsMemoryWritable(e){const t=readConfigRecord(e.workspace.runtime.memory,"deepagentsMem");return!1!==t?.write}function emitInventoryRepair(e,t,o,n,r,i){e.emit({type:"runtime.adapter.event",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,event:{adapter:"deepagents",phase:"inventory.repair",status:t,diagnostic:{layer:"task",owner:"stable_runtime_policy",originalId:o,repairedId:n,candidateIds:r,reason:i}}})}function taskCallCandidates(e,t){return t.map(t=>({id:t,description:e.workspace.agents.get(t)?.description,schema:{type:"object",properties:{subagent_type:{type:"string"},subagentType:{type:"string"},description:{type:"string"}},required:["description"],additionalProperties:!0}}))}function isFilesystemDisabled(e){const t=readConfigRecord(e.agent.config,"builtinTools");return!1===t?.filesystem}function isTaskVisible(e){const t=readConfigRecord(e.agent.config,"builtinTools")?.modelExposed;return!1!==t&&(!Array.isArray(t)||t.includes("task"))}function isModelVisibleBuiltin(e,t){return(!isFilesystemDisabled(e)||!function isFilesystemTool(e){return"string"==typeof e&&m.has(e)}(t))&&("task"!==t||isTaskVisible(e))}function readConfigRecord(e,t){const o=isRecord(e)?e:{};return isRecord(o[t])?o[t]:void 0}function readString(e){return"string"==typeof e&&e.trim()?e:void 0}function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function formatError(e){return e instanceof Error?e.message:String(e)}function previewError(e){const t=e.replace(/\s+/gu," ").trim();return t.length>800?`${t.slice(0,797)}...`:t}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/gateway/tool-evidence.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeAdapter } from "@stable-harness/core";
+export type ObservedToolEvidence = {
+    agentId: string;
+    toolId: string;
+    output: string;
+};
+export declare function observedToolEvidence(input: Parameters<RuntimeAdapter["run"]>[0]): ObservedToolEvidence[];
+export declare function recordObservedToolEvidence(input: Parameters<RuntimeAdapter["run"]>[0], agentId: string, toolId: string, output: string): void;
+export declare function isControlOnlyOutput(output: string): boolean;
+export declare function isSuccessfulEvidenceOutput(output: string): boolean;

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/gateway/tool-evidence.js

@@ -0,0 +1 @@
+const e="deepagents.observedToolEvidence";export function observedToolEvidence(t){const r=t.requestState?.get(e);return Array.isArray(r)?r:[]}export function recordObservedToolEvidence(t,r,o,n){if(!t.requestState||!isSuccessfulEvidenceOutput(n)||isControlOnlyOutput(n))return;const s=observedToolEvidence(t);t.requestState.set(e,[...s,{agentId:r,toolId:o,output:n}].slice(-12))}export function isControlOnlyOutput(e){return/"status"\s*:\s*"(?:duplicate_tool_call|repeated_tool_call_limit|tool_argument_error|delegated_task_repeat_limit|invalid_input|blocked|failed|error|plan_required|dependency_required)"|Status:\s*(?:invalid_input|blocked|failed|error|plan_required|dependency_required)\b|Filesystem builtin tool .* is disabled/iu.test(e)}export function isSuccessfulEvidenceOutput(e){const t=function parseJsonRecord(e){try{const t=JSON.parse(e);return function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}(t)?t:void 0}catch{return}}(e),r="string"==typeof t?.status?t.status:function readTextStatus(e){return String(e).match(/^Status:\s*([A-Za-z0-9_-]+)/imu)?.[1]}(e);return!r||/^(?:completed|success|ok|recorded)$/iu.test(r)}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/gateway/tool-failure-events.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAdapter } from "@stable-harness/core";
+export declare function emitStructuredToolFailure(input: Parameters<RuntimeAdapter["run"]>[0], agentId: string, toolId: string, error: unknown): void;

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/gateway/tool-failure-events.js

@@ -0,0 +1 @@
+import{toolCircuitOpenEvent as e,toolFailureEvent as o}from"@stable-harness/core";export function emitStructuredToolFailure(r,t,s,n){const i=o({requestId:r.requestId,sessionId:r.sessionId,agentId:t,toolId:s,error:n});r.emit(i),r.toolFailureTracker?.recordFailure(s)&&r.emit(e({requestId:r.requestId,sessionId:r.sessionId,agentId:t,toolId:s,reason:"runtime.tool.failure"===i.type?i.failure.reason:"unknown"}))}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/gateway-tools.d.ts

@@ -0,0 +1,33 @@
+import { ToolMessage } from "@langchain/core/messages";
+import type { RuntimeAdapter } from "@stable-harness/core";
+import type { RuntimeToolRepairModel } from "@stable-harness/core";
+export type ToolRepeatState = {
+    successfulCalls: Map<string, string>;
+    duplicateCallCounts: Map<string, number>;
+    latestSuccessfulOutputByTool: Map<string, string>;
+    successfulToolCounts: Map<string, number>;
+    toolCallCounts: Map<string, number>;
+    maxDuplicateCallsPerTool?: number;
+    maxCallsPerTool?: number;
+    maxSuccessfulCallsPerTool?: number;
+    maxCallsByTool: Map<string, number>;
+    maxSuccessfulCallsByTool: Map<string, number>;
+    returnPreviousOutputOnRepeatLimit: boolean;
+};
+export declare function buildGatewayTools(input: Parameters<RuntimeAdapter["run"]>[0], agentId: string, toolIds: string[], repairModel?: RuntimeToolRepairModel, repeatState?: ToolRepeatState | undefined): import("@langchain/core/tools").DynamicTool<string | ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown>[];
+export declare function createToolRepeatState(config: unknown): ToolRepeatState | undefined;
+export declare function beforeToolInvoke(toolId: string, args: unknown, state: ToolRepeatState): {
+    eventOutput: string;
+    modelOutput: string;
+} | undefined;
+export declare function isToolRepeatLimitReached(toolId: string, state: ToolRepeatState | undefined): boolean;
+export declare function afterToolInvoke(toolId: string, args: unknown, output: string, result: unknown, state: ToolRepeatState): {
+    eventOutput?: string;
+    modelOutput?: string;
+};
+export declare function stringifyDeepAgentResult(result: unknown): string;
+export declare function toolControlProjection(output: string): {
+    controlStatus: string;
+} | {
+    controlStatus?: undefined;
+};

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/gateway-tools.js

@@ -0,0 +1 @@
+import{ToolMessage as e}from"@langchain/core/messages";import{tool as t}from"@langchain/core/tools";import{isSuccessfulEvidenceOutput as o,observedToolEvidence as r,recordObservedToolEvidence as n}from"./gateway/tool-evidence.js";import{emitStructuredToolFailure as s}from"./gateway/tool-failure-events.js";export function buildGatewayTools(o,n,a,i,l=createToolRepeatState(o.workspace.runtime.toolGateway)){return o.toolGateway?a.flatMap(a=>{const u=o.toolGateway?.get(a);if(!u)return[];const c=o.workspace.tools.get(a),d=c?.schema??u.schema;return[t(async t=>async function invokeGuardedGatewayTool(t){emitToolResult(t.input,t.agentId,t.toolId,void 0);const o=function missingRequiredPlanContent(e,t){const o=readRecord(e.agent.config.executionContract);if(!0!==o?.requiresPlan)return"";const n=readStringArray(o.planEvidenceTools);if(0===n.length||n.includes(t))return"";const s=new Set(r(e).map(e=>e.toolId));return n.some(e=>s.has(e))?"":["Status: plan_required",`Evidence tool: ${t}`,`Blocker: execution contract requires a planning checkpoint from one of: ${n.join(", ")} before evidence tools run.`,"Instruction: call the planning tool first, then retry this atomic evidence tool with repaired arguments."].join("\n")}(t.input,t.toolId);if(o)return emitToolResult(t.input,t.agentId,t.toolId,o),o;const n=function missingToolDependencyContent(e,t){const o=readRecord(e.agent.config.executionContract),n=readStringArray(readRecord(o.toolDependencies)[t]);if(0===n.length)return"";const s=new Set(r(e).map(e=>e.toolId)),a=n.filter(e=>!s.has(e));return 0===a.length?"":["Status: dependency_required",`Evidence tool: ${t}`,`Blocker: this atomic evidence tool requires completed dependency evidence from: ${a.join(", ")}.`,"Instruction: complete the dependency tool first, evaluate it, then retry this atomic evidence tool."].join("\n")}(t.input,t.toolId);if(n)return emitToolResult(t.input,t.agentId,t.toolId,n),n;const a=t.repeatState?beforeToolInvoke(t.toolId,t.args,t.repeatState):void 0;if(a)return emitToolResult(t.input,t.agentId,t.toolId,a.eventOutput),a.modelOutput;const i=await async function invokeGatewayTool(t,o,r,n,a){try{if(t.toolFailureTracker?.isCircuitOpen(r))throw new Error(`Tool circuit is open: ${r}`);const e=await t.toolGateway.invoke({toolId:r,args:n,repairModel:a,context:{workspaceRoot:t.workspace.root,requestId:t.requestId,sessionId:t.sessionId,agentId:o,requestInput:t.request.input,observedEvidence:formatObservedEvidenceForToolContext(t),approvalIds:readApprovalIds(t.request.metadata)}});return t.toolFailureTracker?.recordSuccess(r),e}catch(n){if(s(t,o,r,n),function isToolArgumentValidationError(e){return e instanceof Error&&"ToolArgumentValidationError"===e.name&&"string"==typeof e.toolId&&Array.isArray(e.issues)}(n))return new e({tool_call_id:`stable-harness-${r}-argument-guard`,name:r,status:"error",content:formatToolArgumentError(n)});if(t.workspace.runtime.retry?.tools?.enabled)throw n;return new e({tool_call_id:`stable-harness-${r}-execution-error`,name:r,status:"error",content:JSON.stringify({error:"tool_execution_failed",toolId:r,message:formatError(n),retry:"Use the error as evidence, adjust the tool arguments if possible, or return a final answer with the blocker."})})}}(t.input,t.agentId,t.toolId,t.args,t.repairModel),l=i instanceof e?String(i.content):stringifyDeepAgentResult(i.output),u=t.repeatState?afterToolInvoke(t.toolId,t.args,l,i,t.repeatState):{};return emitToolResult(t.input,t.agentId,t.toolId,u.eventOutput??l),void 0!==u.modelOutput?u.modelOutput:i instanceof e?i:l}({input:o,agentId:n,toolId:a,args:t,repairModel:i,repeatState:l}),{name:a,description:buildToolDescription(c?.description??u.description??a,d,o.workspace.runtime.toolGateway,a),schema:{type:"object",additionalProperties:!0}})]}):[]}export function createToolRepeatState(e){if(function repeatGuardEnabled(e){return!0===repeatGuardConfig(e).enabled}(e))return{successfulCalls:new Map,duplicateCallCounts:new Map,latestSuccessfulOutputByTool:new Map,successfulToolCounts:new Map,toolCallCounts:new Map,maxDuplicateCallsPerTool:readPositiveInteger(repeatGuardConfig(e).maxDuplicateCallsPerTool)??3,maxCallsPerTool:readPositiveInteger(repeatGuardConfig(e).maxCallsPerTool),maxSuccessfulCallsPerTool:readPositiveInteger(repeatGuardConfig(e).maxSuccessfulCallsPerTool),maxCallsByTool:readPositiveIntegerMap(repeatGuardConfig(e).maxCallsByTool),maxSuccessfulCallsByTool:readPositiveIntegerMap(repeatGuardConfig(e).maxSuccessfulCallsByTool),returnPreviousOutputOnRepeatLimit:!0===repeatGuardConfig(e).returnPreviousOutputOnRepeatLimit}}function repeatGuardConfig(e){return isRecord(e)&&isRecord(e.repeatGuard)?e.repeatGuard:{}}function readPositiveInteger(e){return"number"==typeof e&&Number.isInteger(e)&&e>0?e:void 0}function readPositiveIntegerMap(e){return isRecord(e)?new Map(Object.entries(e).map(([e,t])=>[e,readPositiveInteger(t)]).filter(e=>void 0!==e[1])):new Map}export function beforeToolInvoke(e,t,o){const r=o.toolCallCounts.get(e)??0;o.toolCallCounts.set(e,r+1);const n=o.maxCallsByTool.get(e)??o.maxCallsPerTool;if(void 0!==n&&r>=n){const t=o.latestSuccessfulOutputByTool.get(e),r=repeatedToolCallLimitContent(e,t);return{eventOutput:r,modelOutput:repeatLimitModelOutput(r,t,o)}}const s=o.maxSuccessfulCallsByTool.get(e)??o.maxSuccessfulCallsPerTool;if(void 0!==s&&(o.successfulToolCounts.get(e)??0)>=s){const t=o.latestSuccessfulOutputByTool.get(e),r=repeatedToolCallLimitContent(e,t);return{eventOutput:r,modelOutput:repeatLimitModelOutput(r,t,o)}}const a=stableToolCallKey(e,t),i=o.successfulCalls.get(a);if(void 0!==i){const t=o.duplicateCallCounts.get(a)??0;if(o.duplicateCallCounts.set(a,t+1),void 0!==o.maxDuplicateCallsPerTool&&t>=o.maxDuplicateCallsPerTool){const t=repeatedToolCallLimitContent(e);return{eventOutput:t,modelOutput:t}}const r=function duplicateToolCallContent(e,t){return JSON.stringify({status:"duplicate_tool_call",toolId:e,instruction:"This agent already completed an equivalent tool call. Use the prior evidence instead of calling the tool again.",previousOutput:t})}(e,i);return{eventOutput:r,modelOutput:i}}}function repeatLimitModelOutput(e,t,o){return o.returnPreviousOutputOnRepeatLimit&&void 0!==t&&0!==t.trim().length?t:e}export function isToolRepeatLimitReached(e,t){if(!t)return!1;const o=t.maxCallsByTool.get(e)??t.maxCallsPerTool;if(void 0!==o&&(t.toolCallCounts.get(e)??0)>=o)return!0;const r=t.maxSuccessfulCallsByTool.get(e)??t.maxSuccessfulCallsPerTool;return void 0!==r&&(t.successfulToolCounts.get(e)??0)>=r}export function afterToolInvoke(t,r,n,s,a){return s instanceof e&&"error"===s.status?{}:o(n)?(a.successfulCalls.set(stableToolCallKey(t,r),n),a.latestSuccessfulOutputByTool.set(t,n),a.successfulToolCounts.set(t,(a.successfulToolCounts.get(t)??0)+1),{}):{}}function emitToolResult(e,t,o,r){void 0!==r&&n(e,t,o,r),e.emit({type:"runtime.adapter.event",requestId:e.requestId,sessionId:e.sessionId,agentId:t,event:void 0===r?{adapter:"deepagents",phase:"agent.tool.start",toolId:o}:{adapter:"deepagents",phase:"agent.tool.result",toolId:o,output:previewToolOutput(r),evidenceOutput:r,...toolControlProjection(r)}})}function repeatedToolCallLimitContent(e,t){return JSON.stringify({status:"repeated_tool_call_limit",toolId:e,instruction:"This tool reached the configured repeat limit for this request. Do not call this tool or a substitute tool for the same evidence need again. Use previousOutput and the collected evidence to produce the final answer now, or report the remaining gap explicitly.",...void 0!==t?{previousOutput:t}:{}})}export function stringifyDeepAgentResult(t){if(t instanceof e)return function stringifyToolMessageContent(e){return"string"==typeof e?e:JSON.stringify(e)}(t.content);if("string"==typeof t)return t;if(isRecord(t)){const e=t.structuredResponse??t.structured_response;if(void 0!==e)return"string"==typeof e?e:JSON.stringify(e);const o=(Array.isArray(t.messages)?t.messages:[]).at(-1);if(isRecord(o)&&"string"==typeof o.content)return o.content;const r=(isRecord(t.update)&&Array.isArray(t.update.messages)?t.update.messages:[]).at(-1);if(isRecord(r)&&isRecord(r.kwargs)&&"string"==typeof r.kwargs.content)return r.kwargs.content;if(isRecord(r)&&"string"==typeof r.content)return r.content}return JSON.stringify(t)}function buildToolDescription(e,t,o,r){const n=function toolRepeatPolicyDescription(e,t){const o=repeatGuardConfig(e),r=readPositiveIntegerMap(o.maxSuccessfulCallsByTool).get(t)??readPositiveInteger(o.maxSuccessfulCallsPerTool);return void 0===r?"":`Stable runtime repeat policy: call this tool at most ${r} successful time(s) for this request. If more detail is needed, include the dimensions in the first call and synthesize after the result returns.`}(o,r),s=n?`${e}\n\n${n}`:e;return t?`${s}\n\nStable tool input schema:\n${previewToolOutput(JSON.stringify(t))}`:s}function previewToolOutput(e){const t=e.replace(/\s+/gu," ").trim();return t.length>500?`${t.slice(0,497)}...`:t}export function toolControlProjection(e){const t=function parseJsonRecord(e){try{const t=JSON.parse(e);return isRecord(t)?t:void 0}catch{return}}(e);if("string"==typeof t?.status)return{controlStatus:t.status};const o=function readTextStatus(e){return String(e).match(/^Status:\s*([A-Za-z0-9_-]+)/imu)?.[1]}(e);return o?{controlStatus:o}:"string"==typeof t?.error?{controlStatus:t.error}:e.startsWith("Task delegation target is not in the workspace inventory")?{controlStatus:"task_inventory_blocked"}:{}}function stableToolCallKey(e,t){return`${e}:${stableJson(t)}`}function stableJson(e){return Array.isArray(e)?`[${e.map(stableJson).join(",")}]`:isRecord(e)?`{${Object.keys(e).sort().map(t=>`${JSON.stringify(t)}:${stableJson(e[t])}`).join(",")}}`:JSON.stringify(e)}function readApprovalIds(e){const t=e?.approvalIds??e?.approvalId;return"string"==typeof t&&t.trim()?[t.trim()]:Array.isArray(t)?t.filter(e=>"string"==typeof e&&e.trim().length>0):void 0}function formatObservedEvidenceForToolContext(e){const t=r(e).map(e=>`Tool: ${e.toolId}\n${e.output}`).join("\n\n---\n\n");return t.length>12e3?`${t.slice(0,12e3)}\n[truncated]`:t}function formatToolArgumentError(e){return JSON.stringify({error:"tool_argument_validation_failed",toolId:e.toolId,issues:e.issues,retry:"Call the same tool again with arguments that satisfy the reported schema and semantic issues."})}function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function readRecord(e){return isRecord(e)?e:{}}function readStringArray(e){return Array.isArray(e)?e.filter(e=>"string"==typeof e&&e.length>0):[]}function formatError(e){return e instanceof Error?e.message:String(e)}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/messages.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeAdapter } from "@stable-harness/core";
+type DeepAgentMessage = {
+    role: string;
+    content: string;
+};
+export declare function buildDeepAgentRequest(input: Parameters<RuntimeAdapter["run"]>[0]): {
+    messages: DeepAgentMessage[];
+};
+export {};

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/messages.js

@@ -0,0 +1 @@
+export function buildDeepAgentRequest(e){return{messages:buildDeepAgentMessages(e)}}function buildDeepAgentMessages(e){const t=function readOpenAiMessages(e){return Array.isArray(e)?e.flatMap(e=>{const t=function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}(e)?e:{},n=function readRole(e){if("system"===e||"user"===e||"assistant"===e||"tool"===e)return e}(t.role),r="string"==typeof t.content?t.content:"";return n&&r?[{role:n,content:r}]:[]}):[]}(e.request.metadata?.openaiMessages),n="tool_call"===e.request.metadata?.stableHarnessRecovery?void 0:function buildMemoryContext(e){const t=(e.pluginMemories??[]).filter(e=>e.context.trim()).map(e=>`Memory namespace: ${e.namespace}\n${e.context}`).join("\n\n");return t?`Relevant long-term memory:\n${t}`:void 0}(e);if(t.length>0){const r=function applyRecoveryPrompt(e,t){return"tool_call"!==t.request.metadata?.stableHarnessRecovery?e:[{role:"user",content:t.request.input}]}(t,e);return n?[{role:"system",content:n},...r]:r}const r={role:"user",content:e.request.input};return n?[{role:"system",content:n},r]:[r]}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/raw-tool-call-parser.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeAdapter } from "@stable-harness/core";
+type AdapterRunInput = Parameters<RuntimeAdapter["run"]>[0];
+type ModelRequest = {
+    tools?: Array<{
+        name?: unknown;
+    }>;
+};
+export declare function createRawToolCallParserMiddleware(input: AdapterRunInput): {
+    name: string;
+    wrapModelCall(request: ModelRequest, handler: (request: unknown) => Promise<unknown>): Promise<unknown>;
+};
+export {};

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/raw-tool-call-parser.js

@@ -0,0 +1 @@
+import{AIMessage as e}from"@langchain/core/messages";export function createRawToolCallParserMiddleware(t){return{name:"StableHarnessRawToolCallParser",async wrapModelCall(n,r){const o=await r(n);if(!function rawToolCallParsingEnabled(e){const t=isRecord(e.workspace.runtime.recovery)?e.workspace.runtime.recovery:{};return!0===(isRecord(t.toolCall)?t.toolCall:{}).enabled}(t))return o;const a=function parseRawToolCallResponse(t,n){if(0===n.size||!function isModelResponse(e){return isRecord(e)}(t)||function hasToolCalls(e){return Array.isArray(e.tool_calls)&&e.tool_calls.length>0}(t))return;const r=function readContentText(e){return"string"==typeof e?e.trim()?e:void 0:Array.isArray(e)&&e.map(e=>isRecord(e)&&"string"==typeof e.text?e.text:"").join("\n").trim()||void 0}(t.content);if(!r)return;const o=function readRawToolCalls(e,t){const n=readXmlToolCalls(e,t);if(n.length>0)return n;const r=function stripToolMarkup(e){return e.replace(/^\s*```(?:json)?/iu,"").replace(/```\s*$/iu,"").replace(/^\s*<\s*tool_call[^>]*>\s*/iu,"").replace(/\s*<\s*\/\s*tool_call\s*>\s*$/iu,"").trim()}(e),o=readXmlToolCalls(r,t);if(o.length>0)return o;const a=function readFunctionToolCalls(e,t){const n=[];for(const r of t){const t=new RegExp(`(?:^|\\s)${escapeRegexp(r)}\\s*\\(([^)]*)\\)`,"giu");for(const o of e.matchAll(t)){const e=readFunctionArgs(o[1]??"");e&&Object.keys(e).length>0&&n.push({id:`stable-harness-${r}-${Date.now().toString(36)}`,name:r,args:e})}}return n}(r,t);return a.length>0?a:function parseJsonObjects(e){const t=[];let n=e.indexOf("{");for(;n>=0;){const r=readBalancedJsonObject(e,n);if(r){try{const e=JSON.parse(r);isRecord(e)&&t.push(e)}catch{}n=e.indexOf("{",n+r.length)}else n=e.indexOf("{",n+1)}return t}(r).flatMap(e=>function readJsonToolCall(e,t){const n=function readNestedToolCall(e,t){const n=Object.entries(e);if(1!==n.length)return;const[r,o]=n[0];return t.has(r)&&isRecord(o)?{id:`stable-harness-${r}-${Date.now().toString(36)}`,name:r,args:o}:void 0}(e,t);if(n)return n;const r=readString(e.name)??readString(e.tool_name)??readString(e.tool)??readString(e.type),o=t.has(r??"")?r:singleToolName(t),a=function readArgs(e){return isRecord(e.arguments)?e.arguments:isRecord(e.parameters)?e.parameters:isRecord(e.args)?e.args:"args"in e&&void 0!==e.args?{args:e.args}:void 0}(e)??function readInlineArgs(e){const t=Object.fromEntries(Object.entries(e).filter(([e])=>!["name","tool_name","tool","type"].includes(e)));return Object.keys(t).length>0?t:void 0}(e);return o&&t.has(o)&&a?{id:`stable-harness-${o}-${Date.now().toString(36)}`,name:o,args:a}:void 0}(e,t)??[])}(r,n);return 0!==o.length?new e({content:"",id:"string"==typeof t.id?t.id:void 0,name:"string"==typeof t.name?t.name:void 0,additional_kwargs:isRecord(t.additional_kwargs)?t.additional_kwargs:{},response_metadata:isRecord(t.response_metadata)?t.response_metadata:{},tool_calls:o.map(e=>({id:e.id,name:e.name,args:e.args,type:"tool_call"}))}):void 0}(o,function visibleToolNames(e){return new Set((e.tools??[]).map(e=>e.name).filter(e=>"string"==typeof e&&e.length>0))}(n));return a??o}}}function readXmlToolCalls(e,t){const n=[],r=/<\s*(tool_call|tool_code)\b[^>]*>(?:[\s\S]*?<\s*\/\s*\1\s*>)?/giu;for(const o of e.matchAll(r)){const e=readXmlToolCall(o[0],t);e&&n.push(e)}return n}function readXmlToolCall(e,t){const n=function readToolCallAttributes(e){const t=/<\s*(?:tool_call|tool_code)\b([^>]*)>/iu.exec(e);if(!t)return;const n=[...t[1].matchAll(/([a-zA-Z_][\w.-]*)\s*=\s*"([^"]*)"/gu)];return n.length>0?Object.fromEntries(n.map(e=>[e[1],e[2]])):void 0}(e),r=readString(n?.name)??readString(n?.tool_name)??readString(n?.tool)??readXmlTag(e,"tool_name")??readXmlTag(e,"name")??readXmlTag(e,"tool"),o=t.has(r??"")?r:singleToolName(t);if(!o||!t.has(o))return;const a=readXmlTag(e,"tool_args")??readXmlTag(e,"args")??readXmlTag(e,"arguments"),s=a?function readXmlArgs(e){const t=[...e.matchAll(/<\s*([a-zA-Z_][\w.-]*)\s*>([\s\S]*?)<\s*\/\s*\1\s*>/gu)];if(0===t.length){const t=e.trim();return t?{input:t}:void 0}return Object.fromEntries(t.map(e=>[e[1],e[2].trim()]))}(a):function readAttributeArgs(e){if(!e)return;const t=Object.fromEntries(Object.entries(e).filter(([e])=>!["name","tool_name","tool","type"].includes(e)));return Object.keys(t).length>0?t:void 0}(n);return s&&0!==Object.keys(s).length?{id:`stable-harness-${o}-${Date.now().toString(36)}`,name:o,args:s}:void 0}function readXmlTag(e,t){const n=new RegExp(`<\\s*${t}\\s*>([\\s\\S]*?)<\\s*\\/\\s*${t}\\s*>`,"iu").exec(e);return n?.[1]?.trim()||void 0}function readFunctionArgs(e){const t=[...e.matchAll(/([a-zA-Z_][\w.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^,\s]+))/gu)];return t.length>0?Object.fromEntries(t.map(e=>[e[1],e[2]??e[3]??e[4]??""])):void 0}function readBalancedJsonObject(e,t){let n=0,r=!1,o=!1;for(let a=t;a<e.length;a+=1){const s=e[a];if(r)o="\\"===s&&!o,'"'!==s||o||(r=!1),"\\"!==s&&(o=!1);else if('"'===s&&(r=!0),"{"===s&&(n+=1),"}"===s&&(n-=1),0===n)return e.slice(t,a+1)}}function singleToolName(e){return 1===e.size?[...e][0]:void 0}function escapeRegexp(e){return e.replace(/[.*+?^${}()|[\]\\]/gu,"\\$&")}function readString(e){return"string"==typeof e&&e.trim()?e.trim():void 0}function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/skill-file-policy.d.ts

@@ -0,0 +1,10 @@
+import { ToolMessage } from "@langchain/core/messages";
+import type { RuntimeAdapter } from "@stable-harness/core";
+type AdapterRunInput = Parameters<RuntimeAdapter["run"]>[0];
+export declare function validateSkillFileBuiltinCall(input: AdapterRunInput, toolId: string, request: {
+    toolCall?: {
+        id?: string;
+        args?: unknown;
+    };
+}): ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>> | undefined;
+export {};

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/skill-file-policy.js

@@ -0,0 +1 @@
+import{ToolMessage as e}from"@langchain/core/messages";export function validateSkillFileBuiltinCall(t,l,r){const i=function readFilesystemTarget(e){const t=function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}(e)?e:{};for(const e of["file_path","path","pattern","query"]){const l=t[e];if("string"==typeof l&&l.trim())return l.trim()}}(r.toolCall?.args);if(i&&function targetsRegisteredSkill(e,t){return[...e.workspace.skills.values()].some(l=>{const r=function virtualSkillDir(e,t){const l=function pathRelative(e,t){const l=e.split("/").filter(Boolean),r=t.split("/").filter(Boolean);if(!(r.length<l.length)){for(let e=0;e<l.length;e+=1)if(l[e]!==r[e])return;return r.slice(l.length).join("/")}}(e,t);if(void 0===l)return;const r=l.split("/").filter(Boolean),i=r.lastIndexOf("skills");return i<0?`/${r.slice(0,-1).join("/")}`:`/${r.slice(0,i+2).join("/")}`}(e.workspace.root,l.path);return!!r&&function pathMatches(e,t){const l=t.replace(/\/+$/u,"");return e===l||e.startsWith(`${l}/`)||e.includes(`${l}/`)||e.includes("SKILL.md")}(t,r)})}(t,i))return new e({tool_call_id:r.toolCall?.id??`stable-harness-${l}-skill-policy`,name:l,status:"error",content:[`Filesystem builtin tool '${l}' targeted registered skill inventory: ${i}.`,"Skills are already registered with the backend and are not evidence files for the user request.","Do not read, list, glob, or grep SKILL.md files or skill directories.","Continue with the declared agent tools, the skill behavior already loaded by the backend, and the evidence already collected."].join(" ")})}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/stream-events.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAdapter } from "@stable-harness/core";
+export declare function streamDeepAgentResult(input: Parameters<RuntimeAdapter["run"]>[0], events: AsyncIterable<unknown>, stringify: (value: unknown) => string): Promise<string>;

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/stream-events.js

@@ -0,0 +1 @@
+export async function streamDeepAgentResult(t,e,r){let n,o="";for await(const a of e){const e=readStreamDelta(a);e&&(o+=e,t.emit({type:"runtime.adapter.event",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,event:{adapter:"deepagents",phase:"agent.output.delta",text:e}}));const d=readStreamFinalOutput(a,r);d&&(n=d)}return n??o}function readStreamDelta(t){const e=isRecord(t)?t:{};if("on_chat_model_stream"===e.event)return function readChunkText(t){const e=t?.content;return"string"==typeof e?e:Array.isArray(e)&&e.map(readContentPartText).filter(Boolean).join("")||void 0}(readRecord(readRecord(e.data)?.chunk))}function readContentPartText(t){if("string"==typeof t)return t;const e=isRecord(t)?t:{};return"string"==typeof e.text&&e.text.trim()?e.text:void 0}function readStreamFinalOutput(t,e){const r=isRecord(t)?t:{};if("on_chain_end"!==r.event)return;const n=readRecord(r.data)?.output;return e(n)||void 0}function readRecord(t){return isRecord(t)?t:void 0}function isRecord(t){return"object"==typeof t&&null!==t&&!Array.isArray(t)}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/tool-repeat-visibility.d.ts

@@ -0,0 +1,4 @@
+import type { ToolRepeatState } from "./gateway-tools.js";
+export declare function filterRepeatLimitedTools<T extends {
+    name?: unknown;
+}>(tools: T[] | undefined, repeatState: ToolRepeatState | undefined): T[] | undefined;

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/tool-repeat-visibility.js

@@ -0,0 +1 @@
+import{isToolRepeatLimitReached as e}from"./gateway-tools.js";export function filterRepeatLimitedTools(t,o){return t&&o?t.filter(t=>"string"!=typeof t.name||!e(t.name,o)):t}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/trace-projection.d.ts

@@ -0,0 +1,16 @@
+export declare function traceProjectionForBuiltinTool(toolId: string, phase: "agent.tool.start" | "agent.tool.result", args: unknown): {
+    traceType: string;
+    traceLabel: string;
+    subagentType: string | undefined;
+    todos?: undefined;
+} | {
+    traceType: string;
+    traceLabel: string;
+    todos: any[];
+    subagentType?: undefined;
+} | {
+    traceType?: undefined;
+    traceLabel?: undefined;
+    subagentType?: undefined;
+    todos?: undefined;
+};

package/node_modules/@stable-harness/adapter-deepagents/dist/src/internal/trace-projection.js

@@ -0,0 +1 @@
+export function traceProjectionForBuiltinTool(t,e,r){return"task"===t?{traceType:"delegation",traceLabel:"agent.tool.start"===e?"delegation.start":"delegation.completed",subagentType:readTaskSubagentType(r)}:"write_todos"===t&&"agent.tool.result"===e?{traceType:"plan",traceLabel:"plan.updated",todos:readTodoArgs(r)}:{}}function readTaskSubagentType(t){const e=isRecord(t)?t:{};return readString(e.subagent_type)??readString(e.subagentType)}function readTodoArgs(t){const e=isRecord(t)?t:{};return Array.isArray(e.todos)?e.todos:[]}function isRecord(t){return"object"==typeof t&&null!==t&&!Array.isArray(t)}function readString(t){return"string"==typeof t&&t.trim()?t:void 0}

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

@@ -0,0 +1,5 @@
+import type { CompiledWorkspace, MemoryMaintenanceResult, MemoryMaintenanceTarget, MemoryMaintenanceTargetInput } from "@stable-harness/core";
+export declare function resolveDeepAgentsNativeMemories(workspace: CompiledWorkspace): import("@stable-harness/core").WorkspaceMemory[];
+export declare function createDeepAgentsMemoryMaintenanceTarget(input?: {
+    run?: (context: MemoryMaintenanceTargetInput) => Promise<MemoryMaintenanceResult>;
+}): MemoryMaintenanceTarget;

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

@@ -0,0 +1 @@
+import{resolveEnabledMemories as e}from"@stable-harness/core";export function resolveDeepAgentsNativeMemories(r){return!1===function readMemoryFlag(e,r,n){const o=readRecord(e[r])??readRecord(e[r.toLowerCase()]);return"boolean"==typeof o?.[n]?o[n]:void 0}(r.runtime.memory??{},"deepagentsMem","read")?[]:e(r,"all")}export function createDeepAgentsMemoryMaintenanceTarget(e={}){return{name:"deepagentsMem",run:async r=>e.run?e.run(r):{operations:[],metadata:{skipped:!0,reason:"No DeepAgents memory maintainer configured"}}}}function readRecord(e){return"object"!=typeof e||null===e||Array.isArray(e)?void 0:e}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/model-providers.d.ts

@@ -0,0 +1,4 @@
+import { ChatOllama } from "@langchain/ollama";
+import { ChatOpenAI } from "@langchain/openai";
+import type { WorkspaceModel } from "@stable-harness/core";
+export declare function createBackendModel(model: WorkspaceModel): string | ChatOpenAI<import("@langchain/openai").ChatOpenAICallOptions> | ChatOllama;

package/node_modules/@stable-harness/adapter-deepagents/dist/src/model-providers.js

@@ -0,0 +1 @@
+import{ChatOllama as e}from"@langchain/ollama";import{ChatOpenAI as r}from"@langchain/openai";export function createBackendModel(r){return"ollama"===r.provider?function usesOpenAiCompatibleToolCalling(e){const r=readString(e.config?.toolCallingMode);return"openai-compatible"===r||"structured"===r}(r)?createOpenAiCompatibleModel({...r,config:{...r.config,baseURL:readOllamaOpenAiBaseUrl(r.config?.baseURL??r.config?.baseUrl)}}):function createOllamaModel(r){return new e(pruneUndefined({model:r.model,baseUrl:readString(r.config?.baseUrl),temperature:readNumber(r.config?.temperature),numCtx:readNumber(r.config?.numCtx),numPredict:readNumber(r.config?.numPredict),timeout:readNumber(r.config?.timeout),think:"boolean"==typeof r.config?.think?r.config.think:void 0}))}(r):"openai-compatible"===r.provider?createOpenAiCompatibleModel(r):r.model}function createOpenAiCompatibleModel(e){return new r(pruneUndefined({model:e.model,apiKey:readString(e.config?.apiKey),temperature:readNumber(e.config?.temperature),maxTokens:readNumber(e.config?.maxTokens)??readNumber(e.config?.numPredict),timeout:readNumber(e.config?.timeout),modelKwargs:readOpenAiCompatibleModelKwargs(e.config),configuration:pruneUndefined({baseURL:readString(e.config?.baseURL)??readString(e.config?.baseUrl),defaultHeaders:readStringRecord(e.config?.headers)})}))}function readOpenAiCompatibleModelKwargs(e){const r={...readRecord(e?.extraBody),...readRecord(e?.modelKwargs)},n=pruneUndefined({...r,think:r.think??("boolean"==typeof e?.think?e.think:void 0),num_ctx:r.num_ctx??readNumber(e?.numCtx),num_predict:r.num_predict??readNumber(e?.numPredict)});return Object.keys(n).length>0?n:void 0}function pruneUndefined(e){return Object.fromEntries(Object.entries(e).filter(([,e])=>void 0!==e))}function readString(e){return"string"==typeof e&&e.trim()?e:void 0}function readNumber(e){return"number"==typeof e&&Number.isFinite(e)?e:void 0}function readStringRecord(e){if("object"!=typeof e||null===e||Array.isArray(e))return;const r=Object.entries(e).filter(e=>"string"==typeof e[1]);return r.length>0?Object.fromEntries(r):void 0}function readRecord(e){return"object"!=typeof e||null===e||Array.isArray(e)?{}:e}function readOllamaOpenAiBaseUrl(e){const r=readString(e);if(!r)return;const n=r.replace(/\/+$/u,"");return n.endsWith("/v1")?n:`${n}/v1`}

package/node_modules/@stable-harness/adapter-deepagents/dist/src/retry-policy.d.ts

@@ -0,0 +1,2 @@
+import type { WorkspaceRetryPolicy } from "@stable-harness/core";
+export declare function createDeepAgentsRetryMiddleware(policy: WorkspaceRetryPolicy | undefined): unknown[];

package/node_modules/@stable-harness/adapter-deepagents/dist/src/retry-policy.js

@@ -0,0 +1 @@
+import{modelRetryMiddleware as e,toolRetryMiddleware as t}from"langchain";export function createDeepAgentsRetryMiddleware(r){const n=[],o=readRetryOptions(r?.model);o&&n.push(e(o));const i=function readToolRetryOptions(e){const t=readRetryOptions(e);if(!t)return;const r=Array.isArray(e?.tools)?e.tools.filter(e=>"string"==typeof e&&e.trim().length>0):void 0;return pruneUndefined({...t,tools:r})}(r?.tools);return i&&n.push(t(i)),n}function readRetryOptions(e){var t;if(e?.enabled)return pruneUndefined({maxRetries:readNonNegativeNumber(e.maxRetries),backoffFactor:readNonNegativeNumber(e.backoffFactor),initialDelayMs:readNonNegativeNumber(e.initialDelayMs),maxDelayMs:readNonNegativeNumber(e.maxDelayMs),jitter:"boolean"==typeof e.jitter?e.jitter:void 0,retryOn:createRetryPredicate(e.retryOn),onFailure:(t=e.onFailure,"continue"===t||"error"===t?t:void 0)})}function readNonNegativeNumber(e){return"number"==typeof e&&Number.isFinite(e)&&e>=0?e:void 0}function createRetryPredicate(e){const t=function readRetryReasons(e){const t=new Set(["timeout","network","rateLimit","serverError"]);if(!Array.isArray(e))return[...t];const r=e.filter(e=>t.has(e));return r.length>0?r:[...t]}(e);return e=>t.some(t=>matchesRetryReason(e,t))}function matchesRetryReason(e,t){const r=isRecord(e)?e:{},n=function readStatus(e){const t=e.status??e.statusCode??e.code;return"number"==typeof t?t:Number.isInteger(Number(t))?Number(t):void 0}(r),o=`${String(r.name??"")} ${String(r.code??"")} ${String(r.message??e)}`,i=r.cause;return("timeout"===t?/timeout|timedout|etimedout|abort/i.test(o):"network"===t?/network|fetch failed|terminated|connection error|eof|econnreset|econnrefused|enotfound|eai_again/i.test(o):"rateLimit"===t?429===n||/rate.?limit|too many requests/i.test(o):"serverError"===t&&Boolean(n&&n>=500&&n<600))||isRecord(i)&&matchesRetryReason(i,t)}function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function pruneUndefined(e){return Object.fromEntries(Object.entries(e).filter(([,e])=>void 0!==e))}

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

@@ -0,0 +1,12 @@
+import type { RuntimeAdapterContext, RuntimeAdapterResult } from "@stable-harness/core";
+export type DeepAgentFactory = (params?: Record<string, unknown>) => {
+    invoke(input: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    streamEvents?(input: Record<string, unknown>, options?: Record<string, unknown>): AsyncIterable<unknown>;
+};
+export type DeepAgentsModule = {
+    createDeepAgent?: unknown;
+    FilesystemBackend?: new (options: {
+        rootDir: string;
+    }) => unknown;
+};
+export type DeepAgentsAdapterRunner = (input: RuntimeAdapterContext) => Promise<RuntimeAdapterResult>;

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

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

package/node_modules/@stable-harness/adapter-deepagents/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@stable-harness/adapter-deepagents",
+  "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": {
+    "@botbotgo/better-call": "^0.1.58",
+    "@langchain/core": "^1.1.43",
+    "@langchain/ollama": "^1.2.7",
+    "@langchain/openai": "^1.4.5",
+    "@stable-harness/core": "0.0.1",
+    "deepagents": "^1.9.1",
+    "langchain": "^1.3.1"
+  },
+  "peerDependenciesMeta": {
+    "deepagents": {
+      "optional": true
+    }
+  }
+}

package/node_modules/@stable-harness/adapter-langgraph/dist/src/graph.d.ts

@@ -0,0 +1,3 @@
+import { type RuntimeOutput, type RuntimeWorkflowAdapterInput } from "@stable-harness/core";
+import type { LangGraphWorkflowAdapterOptions } from "./types.js";
+export declare function runLangGraphWorkflow(input: RuntimeWorkflowAdapterInput, options: LangGraphWorkflowAdapterOptions, adapterName: string): Promise<RuntimeOutput>;

package/node_modules/@stable-harness/adapter-langgraph/dist/src/graph.js

@@ -0,0 +1 @@
+import{Annotation as o,END as e,START as t,StateGraph as n}from"@langchain/langgraph";import{compileWorkflowPlan as r}from"@stable-harness/core";import{resolveSkillProvider as a}from"./skill-providers.js";export async function runLangGraphWorkflow(a,d,i){!function assertSupportedPlan(o){if(o.cycles.length>0)throw new Error(`LangGraph workflow adapter does not enable cyclic graphs by default: ${o.workflowId}`);if(o.unreachableNodes.length>0)throw new Error(`LangGraph workflow has unreachable nodes: ${o.unreachableNodes.join(", ")}`)}(r(a.workflow));const s=function compileLangGraph(a,d,i){let s=new n(function createStateAnnotation(){return o.Root({input:o,outputs:o({reducer:(o,e)=>({...o,...e}),default:()=>({})}),trace:o({reducer:(o,e)=>[...o,...e],default:()=>[]})})}());for(const o of a.workflow.nodes)s=s.addNode(o.id,async e=>runNode({input:a,node:o,state:e,options:d,adapterName:i}));s=s.addEdge(t,a.workflow.entry??a.workflow.nodes[0].id),s=function addStaticEdges(o,e){for(const t of e.workflow.edges)t.condition||(o=o.addEdge(t.from,t.to));return o}(s,a),s=function addConditionalEdges(o,e,t){for(const[n,r]of function conditionalEdgesBySource(o){const e=new Map;for(const t of o.workflow.edges){if(!t.condition)continue;const o=e.get(t.from)??[];o.push({condition:t.condition,to:t.to}),e.set(t.from,o)}return e}(e)){const a=t.conditionalRouters?.[n];if(!a)throw new Error(`LangGraph workflow conditional edges from ${n} require a conditional router`);o=o.addConditionalEdges(n,async o=>a({...e,from:n,edges:r,state:o}),Object.fromEntries(r.map(o=>[o.condition,o.to])))}return o}(s,a,d);for(const o of r(a.workflow).terminalNodes)s=s.addEdge(o,e);return s.compile()}(a,d,i);a.emit({adapter:i,phase:"agent.langgraph.invoke",workflowId:a.workflow.id});const u=await s.invoke({input:a.request.input,outputs:{},trace:[]});return{text:stringifyWorkflowOutput(u),metadata:{workflowId:a.workflow.id,adapter:i,outputs:u.outputs,trace:u.trace}}}async function runNode(o){const e=await function resolveNodeHandler(o,e){const t=e.nodeHandlers?.[o.id]??e.nodeHandlers?.[o.use];if(t)return t;const n=function parseNodeUse(o){const e=o.indexOf(".");if(!(e<=0||e===o.length-1))return{kind:o.slice(0,e),id:o.slice(e+1)}}(o.use);if("workflows"===n?.kind&&e.enableSubworkflows)return o=>async function runSubworkflow(o,e){const t=o.workspace.workflows.get(o.id);if(!t)throw new Error(`LangGraph subworkflow is not defined: ${o.id}`);const n=function readSubworkflowDepth(o){const e=o?.subworkflowDepth;return"number"==typeof e&&Number.isFinite(e)?e:0}(o.request.metadata),r=e.maxSubworkflowDepth??8;if(n>=r)throw new Error(`LangGraph subworkflow depth exceeded ${r}`);return(await runLangGraphWorkflow({...o,workflow:t,request:{...o.request,input:o.state,metadata:{...o.request.metadata,subworkflowDepth:n+1}}},e,e.name??"langgraph")).text}({...o,id:n.id},e);const r=n?e.nodeResolvers?.[n.kind]:void 0;if(r&&n)return o=>r({...o,kind:n.kind,id:n.id});const d="skills"===n?.kind?a(e):void 0;if(d&&n)return o=>d.resolve({...o,kind:n.kind,id:n.id});const i=e.defaultNodeHandler;if(i)return i;throw new Error(`LangGraph workflow node ${o.id} (${o.use}) has no handler or resolver`)}(o.node,o.options)({...o.input,node:o.node,state:o.state});return o.input.emit({adapter:o.adapterName,phase:"agent.node.completed",workflowId:o.input.workflow.id,nodeId:o.node.id}),{outputs:{[o.node.id]:e},trace:[{nodeId:o.node.id,use:o.node.use,output:e}]}}function stringifyWorkflowOutput(o){const e=o.trace.at(-1)?.output;return"string"==typeof e?e:JSON.stringify(e??o.outputs)}

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

@@ -0,0 +1,8 @@
+import type { RuntimeWorkflowAdapter } from "@stable-harness/core";
+import { createLangGraphRuntimeAdapter } from "./runtime.js";
+import { createDeepAgentsMiddlewareSkillProvider, createRegistrySkillResolverProvider } from "./skill-providers.js";
+import type { LangGraphWorkflowAdapterOptions } from "./types.js";
+export type { LangGraphConditionalRouter, LangGraphConditionalRouterInput, LangGraphNodeHandler, LangGraphNodeHandlerInput, LangGraphNodeResolver, LangGraphNodeResolverInput, LangGraphSkillMiddlewareProvider, LangGraphSkillMiddlewareProviderInput, LangGraphSkillResolverProvider, LangGraphWorkflowAdapterOptions, LangGraphWorkflowState, LangGraphWorkflowTraceEntry, } from "./types.js";
+export type { LangGraphRegistrySkillOutput } from "./skill-providers.js";
+export { createDeepAgentsMiddlewareSkillProvider, createLangGraphRuntimeAdapter, createRegistrySkillResolverProvider, };
+export declare function createLangGraphWorkflowAdapter(options?: LangGraphWorkflowAdapterOptions): RuntimeWorkflowAdapter;

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

@@ -0,0 +1 @@
+import{runLangGraphWorkflow as r}from"./graph.js";import{createLangGraphRuntimeAdapter as e}from"./runtime.js";import{createDeepAgentsMiddlewareSkillProvider as a,createRegistrySkillResolverProvider as t}from"./skill-providers.js";export{a as createDeepAgentsMiddlewareSkillProvider,e as createLangGraphRuntimeAdapter,t as createRegistrySkillResolverProvider};export function createLangGraphWorkflowAdapter(e={}){const a=e.name??"langgraph";return{name:a,run:t=>r(t,e,a)}}

package/node_modules/@stable-harness/adapter-langgraph/dist/src/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeAdapter } from "@stable-harness/core";
+import type { LangGraphWorkflowAdapterOptions } from "./types.js";
+export declare function createLangGraphRuntimeAdapter(options?: LangGraphWorkflowAdapterOptions): RuntimeAdapter;

package/node_modules/@stable-harness/adapter-langgraph/dist/src/runtime.js

@@ -0,0 +1 @@
+import{runLangGraphWorkflow as e}from"./graph.js";export function createLangGraphRuntimeAdapter(n={}){const t=n.name??"langgraph";return{name:t,canRun:e=>e.backend===t,run:r=>async function runLangGraphAgent(n,t,r){return e({workspace:n.workspace,workflow:workflowFromAgent(n.agent,r),request:{input:n.request.input,metadata:n.request.metadata},requestId:n.requestId,sessionId:n.sessionId,toolGateway:n.toolGateway,emit:e=>n.emit({type:"runtime.adapter.event",requestId:n.requestId,sessionId:n.sessionId,agentId:n.agent.id,event:e})},t,r)}(r,n,t)}}function workflowFromAgent(e,n){const t=e.edges??[],r=t.length>0?agentNodes(e):agentNodes(e).slice(0,1);return function validateAgentGraph(e,n){const t=new Set;for(const r of n){if(t.has(r.id))throw new Error(`LangGraph agent ${e.id} has duplicate graph node ${r.id}`);t.add(r.id)}for(const n of e.edges??[])if(!t.has(n.from)||!t.has(n.to))throw new Error(`LangGraph agent ${e.id} edge references unknown node ${n.from}->${n.to}`)}({...e,edges:t},r),{id:e.id,...e.description?{description:e.description}:{},...e.sourcePath?{sourcePath:e.sourcePath}:{},adapter:n,entry:readAgentEntry(e,r),nodes:r,edges:t,...Object.keys(e.config).length>0?{config:e.config}:{}}}function agentNodes(e){return[...e.subagents.map(e=>inventoryNode("agents",e)),...(e.skills??[]).map(e=>inventoryNode("skills",e)),...e.tools.map(e=>inventoryNode("tools",e))]}function inventoryNode(e,n){return{id:n,use:`${e}.${n}`}}function readAgentEntry(e,n){return e.edges?.[0]?.from??n[0]?.id}

package/node_modules/@stable-harness/adapter-langgraph/dist/src/skill-providers.d.ts

@@ -0,0 +1,29 @@
+import type { LangGraphSkillMiddlewareProvider, LangGraphSkillResolverProvider } from "./types.js";
+type RegistrySkillResolverOptions = {
+    includeContent?: boolean;
+    maxBytes?: number;
+};
+type DeepAgentsSkillsModule = {
+    createSkillsMiddleware?: (options: Record<string, unknown>) => unknown;
+    FilesystemBackend?: new (options: {
+        rootDir: string;
+    }) => unknown;
+};
+type DeepAgentsMiddlewareProviderOptions = {
+    backend?: unknown;
+    sources?: string[];
+    importDeepAgents?: () => Promise<DeepAgentsSkillsModule>;
+};
+export type LangGraphRegistrySkillOutput = {
+    id: string;
+    path: string;
+    description?: string;
+    allowedTools: string[];
+    content?: string;
+};
+export declare function createRegistrySkillResolverProvider(options?: RegistrySkillResolverOptions): LangGraphSkillResolverProvider;
+export declare function createDeepAgentsMiddlewareSkillProvider(options?: DeepAgentsMiddlewareProviderOptions): LangGraphSkillMiddlewareProvider;
+export declare function resolveSkillProvider(options: {
+    skillProvider?: LangGraphSkillResolverProvider | false;
+}): LangGraphSkillResolverProvider | undefined;
+export {};

package/node_modules/@stable-harness/adapter-langgraph/dist/src/skill-providers.js

@@ -0,0 +1 @@
+import{readFile as e}from"node:fs/promises";import r from"node:path";import{repairRuntimeSelection as t}from"@stable-harness/core";export function createRegistrySkillResolverProvider(e={}){return{name:"registry-resolver",resolve:r=>async function resolveRegistrySkill(e,r){const i=await async function resolveWorkspaceSkill(e){const r=e.workspace.skills.get(e.id);if(r)return r;const i=await t({id:e.id,candidates:[...e.workspace.skills.values()].map(e=>({id:e.id,description:e.description}))});return e.emit({phase:"inventory.repair",status:i.ok?"repaired":"blocked",diagnostic:{layer:"skill",owner:"protocol_adapter",originalId:i.diagnostics?.originalId??e.id,repairedId:i.ok?i.id:i.diagnostics?.repairedId,candidateIds:[...e.workspace.skills.keys()],...i.ok?{}:{reason:i.reason},matchSource:i.diagnostics?.matchSource,confidence:i.diagnostics?.confidence}}),i.ok?e.workspace.skills.get(i.id):void 0}(e);if(!i)throw new Error(`LangGraph skill resolver cannot find skill ${e.id}`);return{id:i.id,path:i.path,...i.description?{description:i.description}:{},allowedTools:i.allowedTools,...!1===r.includeContent?{}:{content:await readSkillContent(i,r.maxBytes)}}}(r,e)}}export function createDeepAgentsMiddlewareSkillProvider(e={}){return{name:"deepagents-middleware",async createMiddleware(r){const t=await async function loadDeepAgentsSkillsModule(e){return e.importDeepAgents?e.importDeepAgents():import("deepagents")}(e),i=t.createSkillsMiddleware;if("function"!=typeof i)throw new Error("deepagents does not export createSkillsMiddleware");return i({backend:e.backend??createDeepAgentsFilesystemBackend(t,r.workspace.root),sources:e.sources??deriveDeepAgentsSkillSources(r)})}}}export function resolveSkillProvider(e){if(!1!==e.skillProvider)return e.skillProvider??createRegistrySkillResolverProvider()}async function readSkillContent(r,t=1048576){const i=await e(r.path,"utf8");if(Buffer.byteLength(i,"utf8")>t)throw new Error(`Skill ${r.id} exceeds registry resolver size limit of ${t} bytes`);return i}function createDeepAgentsFilesystemBackend(e,r){if("function"!=typeof e.FilesystemBackend)throw new Error("deepagents does not export FilesystemBackend");return new e.FilesystemBackend({rootDir:r})}function deriveDeepAgentsSkillSources(e){const t=new Set([...(i=e.agent,i?.skills??[]),...skillIdsFromWorkflow(e)]);var i;const o=new Set;for(const i of t){const t=e.workspace.skills.get(i);t&&o.add(toPosixPath(r.relative(e.workspace.root,r.dirname(r.dirname(t.path)))))}return[...o].filter(e=>e&&!e.startsWith(".."))}function skillIdsFromWorkflow(e){return e.workflow.nodes.map(e=>e.use.match(/^skills\.([^./][^.]*)$/u)?.[1]).filter(e=>Boolean(e))}function toPosixPath(e){return e.split(r.sep).join("/")}

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

@@ -0,0 +1,60 @@
+import type { RuntimeWorkflowAdapterInput, WorkspaceAgent, WorkspaceWorkflowNode } from "@stable-harness/core";
+export type LangGraphWorkflowState = {
+    input?: unknown;
+    outputs: Record<string, unknown>;
+    trace: LangGraphWorkflowTraceEntry[];
+};
+export type LangGraphWorkflowTraceEntry = {
+    nodeId: string;
+    use: string;
+    output: unknown;
+};
+export type LangGraphNodeHandlerInput = RuntimeWorkflowAdapterInput & {
+    node: WorkspaceWorkflowNode;
+    state: LangGraphWorkflowState;
+};
+export type LangGraphNodeHandler = (input: LangGraphNodeHandlerInput) => Promise<unknown> | unknown;
+export type LangGraphNodeResolverInput = LangGraphNodeHandlerInput & {
+    kind: string;
+    id: string;
+};
+export type LangGraphNodeResolver = (input: LangGraphNodeResolverInput) => Promise<unknown> | unknown;
+export type LangGraphSkillResolverProvider = {
+    name: string;
+    resolve(input: LangGraphNodeResolverInput): Promise<unknown> | unknown;
+};
+export type LangGraphSkillMiddlewareProviderInput = RuntimeWorkflowAdapterInput & {
+    agent?: WorkspaceAgent;
+};
+export type LangGraphSkillMiddlewareProvider = {
+    name: string;
+    createMiddleware(input: LangGraphSkillMiddlewareProviderInput): Promise<unknown> | unknown;
+};
+export type LangGraphConditionalRouterInput = RuntimeWorkflowAdapterInput & {
+    from: string;
+    edges: Array<{
+        condition: string;
+        to: string;
+    }>;
+    state: LangGraphWorkflowState;
+};
+export type LangGraphConditionalRouter = (input: LangGraphConditionalRouterInput) => Promise<string> | string;
+export type LangGraphWorkflowAdapterOptions = {
+    name?: string;
+    nodeHandlers?: Record<string, LangGraphNodeHandler>;
+    nodeResolvers?: Record<string, LangGraphNodeResolver>;
+    skillProvider?: LangGraphSkillResolverProvider | false;
+    defaultNodeHandler?: LangGraphNodeHandler;
+    conditionalRouters?: Record<string, LangGraphConditionalRouter>;
+    enableSubworkflows?: boolean;
+    maxSubworkflowDepth?: number;
+};
+export type LangGraphCompiled = {
+    invoke(input: LangGraphWorkflowState): Promise<LangGraphWorkflowState>;
+};
+export type LangGraphBuilder = {
+    addNode(name: string, handler: (state: LangGraphWorkflowState) => Promise<Partial<LangGraphWorkflowState>>): LangGraphBuilder;
+    addEdge(from: string, to: string): LangGraphBuilder;
+    addConditionalEdges(from: string, router: (state: LangGraphWorkflowState) => Promise<string>, pathMap: Record<string, string>): LangGraphBuilder;
+    compile(): LangGraphCompiled;
+};

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

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

package/node_modules/@stable-harness/adapter-langgraph/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@stable-harness/adapter-langgraph",
+  "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": {
+    "@langchain/langgraph": "^1.3.0",
+    "@stable-harness/core": "0.0.1"
+  }
+}