@botbotgo/agent-harness 0.0.55 → 0.0.57

package/dist/runtime/agent-runtime-adapter.js

@@ -1,4 +1,6 @@
 import path from "node:path";
+import { existsSync, statSync } from "node:fs";
+import { cp, mkdir, rm } from "node:fs/promises";
 import { Command, MemorySaver } from "@langchain/langgraph";
 import { tool as createLangChainTool } from "@langchain/core/tools";
 import { createDeepAgent, createMemoryMiddleware, createSkillsMiddleware, createSubAgentMiddleware, FilesystemBackend, } from "deepagents";
@@ -16,6 +18,7 @@ import { wrapToolForExecution } from "./tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./declared-middleware.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 import { getBindingDeepAgentParams, getBindingInterruptCompatibilityRules, getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingModelInit, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { readSkillMetadata } from "./support/skill-metadata.js";
 function countConfiguredTools(binding) {
     return getBindingPrimaryTools(binding).length;
 }
@@ -52,6 +55,65 @@ function computeRemainingTimeoutMs(deadlineAt, fallbackTimeoutMs) {
 function isPlaceholderApiKey(value) {
     return typeof value === "string" && value.trim().toLowerCase() === "dummy";
 }
+export function relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) {
+    if (!workspaceRoot || !skillPaths) {
+        return skillPaths;
+    }
+    return skillPaths.map((skillPath) => {
+        if (!path.isAbsolute(skillPath)) {
+            return skillPath;
+        }
+        const relative = path.relative(workspaceRoot, skillPath);
+        if (!relative || relative.startsWith("..")) {
+            return skillPath;
+        }
+        return relative.split(path.sep).join("/");
+    });
+}
+function isDeepAgentSkillDirectory(sourcePath) {
+    return existsSync(sourcePath) && statSync(sourcePath).isDirectory() && existsSync(path.join(sourcePath, "SKILL.md"));
+}
+function toWorkspaceRelativePath(workspaceRoot, targetPath) {
+    if (!workspaceRoot) {
+        return targetPath;
+    }
+    const relative = path.relative(workspaceRoot, targetPath);
+    if (!relative || relative.startsWith("..")) {
+        return targetPath;
+    }
+    return relative.split(path.sep).join("/");
+}
+export async function materializeDeepAgentSkillSourcePaths(options) {
+    const { workspaceRoot, runRoot, ownerId, skillPaths } = options;
+    if (!skillPaths) {
+        return skillPaths;
+    }
+    const materialized = relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) ?? skillPaths;
+    if (!workspaceRoot || !runRoot) {
+        return materialized;
+    }
+    const sourceRoot = path.join(runRoot, "deepagent-skill-sources", ownerId);
+    let wroteSyntheticSource = false;
+    const resolvedSources = [];
+    for (const [index, sourcePath] of materialized.entries()) {
+        const absolutePath = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(workspaceRoot, sourcePath);
+        if (!isDeepAgentSkillDirectory(absolutePath)) {
+            resolvedSources.push(sourcePath);
+            continue;
+        }
+        if (!wroteSyntheticSource) {
+            await rm(sourceRoot, { recursive: true, force: true });
+            await mkdir(sourceRoot, { recursive: true });
+            wroteSyntheticSource = true;
+        }
+        const skillDirectoryName = path.basename(absolutePath);
+        const syntheticSourcePath = path.join(sourceRoot, `${String(index + 1).padStart(3, "0")}-${skillDirectoryName}`);
+        await mkdir(syntheticSourcePath, { recursive: true });
+        await cp(absolutePath, path.join(syntheticSourcePath, skillDirectoryName), { recursive: true });
+        resolvedSources.push(toWorkspaceRelativePath(workspaceRoot, syntheticSourcePath));
+    }
+    return resolvedSources;
+}
 function buildAuthOmittingFetch(baseFetch = fetch) {
     return async (input, init) => {
         const sanitizedHeaders = new Headers(input instanceof Request ? input.headers : undefined);
@@ -399,11 +461,42 @@ export class AgentRuntimeAdapter {
             { role: "user", content: normalizeMessageContent(input) },
         ];
     }
-    buildInvocationRequest(history, input, options = {}) {
+    buildSlashCommandSkillInstruction(binding, input) {
+        const inputText = extractMessageText(input).trim();
+        const match = inputText.match(/^\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?$/i);
+        if (!match) {
+            return undefined;
+        }
+        const invokedName = match[1].toLowerCase();
+        const argumentText = match[2]?.trim() ?? "";
+        const skillPaths = binding.deepAgentParams?.skills ?? binding.langchainAgentParams?.skills ?? [];
+        const matchedSkillPath = skillPaths.find((skillPath) => readSkillMetadata(skillPath).name.toLowerCase() === invokedName);
+        if (!matchedSkillPath) {
+            return undefined;
+        }
+        const metadata = readSkillMetadata(matchedSkillPath);
+        const skillQualifier = metadata.userInvocable === true ? "user-invocable skill" : "skill";
+        const dryRunHint = /\s--dry-run(?:\s|$)/.test(` ${argumentText} `)
+            ? "This invocation includes `--dry-run`. Perform the real fetch or inspection steps needed for dry-run output. Do not return hypothetical or mock results."
+            : undefined;
+        return [
+            `This user message is an explicit command-style invocation of the ${skillQualifier} \`${metadata.name}\`.`,
+            `Read the skill file for \`${metadata.name}\` before taking action, then follow its documented phases and constraints exactly.`,
+            `You must use the \`${metadata.name}\` skill for this request and follow its documented workflow.`,
+            `Treat everything after \`/${metadata.name}\` as the skill argument string: ${argumentText ? JSON.stringify(argumentText) : '""'}.`,
+            "Do not answer with a generic explanation of what the skill would do. Execute the skill workflow using the available tools unless the skill instructions explicitly require confirmation before acting.",
+            dryRunHint,
+        ].filter((line) => typeof line === "string" && line.length > 0).join("\n");
+    }
+    buildInvocationRequest(binding, history, input, options = {}) {
+        const userInvocableInstruction = this.buildSlashCommandSkillInstruction(binding, input);
+        const messages = this.buildAgentMessages(history, input);
         return {
             ...(options.state ?? {}),
             ...(options.files ? { files: options.files } : {}),
-            messages: this.buildAgentMessages(history, input),
+            messages: userInvocableInstruction
+                ? [{ role: "system", content: userInvocableInstruction }, ...messages]
+                : messages,
         };
     }
     buildStateSnapshot(result) {
@@ -414,11 +507,15 @@ export class AgentRuntimeAdapter {
         delete snapshot.files;
         return Object.keys(snapshot).length > 0 ? snapshot : undefined;
     }
-    buildRawModelMessages(systemPrompt, history, input) {
+    buildRawModelMessages(binding, systemPrompt, history, input) {
         const messages = [];
         if (systemPrompt) {
             messages.push({ role: "system", content: systemPrompt });
         }
+        const userInvocableInstruction = this.buildSlashCommandSkillInstruction(binding, input);
+        if (userInvocableInstruction) {
+            messages.push({ role: "system", content: userInvocableInstruction });
+        }
         messages.push(...this.buildAgentMessages(history, input));
         return messages;
     }
@@ -525,6 +622,8 @@ export class AgentRuntimeAdapter {
     async resolveMiddleware(binding, interruptOn) {
         const declarativeMiddleware = await resolveDeclaredMiddleware(getBindingMiddlewareConfigs(binding), {
             resolveModel: (model) => this.resolveModel(model),
+            resolveBackend: (resolvedBinding) => this.options.backendResolver?.(resolvedBinding ?? binding),
+            resolveFilesystemBackend: (resolvedBinding) => this.resolveFilesystemBackend(resolvedBinding ?? binding),
             resolveCustom: this.options.declaredMiddlewareResolver,
             binding,
         });
@@ -570,11 +669,25 @@ export class AgentRuntimeAdapter {
             ...(subagent.passthrough ?? {}),
             model: subagent.model ? (await this.resolveModel(subagent.model)) : undefined,
             tools: subagent.tools ? this.resolveTools(subagent.tools) : undefined,
+            skills: await materializeDeepAgentSkillSourcePaths({
+                workspaceRoot: binding?.harnessRuntime.workspaceRoot,
+                runRoot: binding?.harnessRuntime.runRoot,
+                ownerId: `${binding?.agent.id ?? "agent"}-${subagent.name}`,
+                skillPaths: subagent.skills,
+            }),
             interruptOn: this.compileInterruptOn(subagent.tools ?? [], subagent.interruptOn),
             responseFormat: subagent.responseFormat,
             contextSchema: subagent.contextSchema,
             middleware: (await resolveDeclaredMiddleware(subagent.middleware, {
                 resolveModel: (model) => this.resolveModel(model),
+                resolveBackend: (resolvedBinding) => {
+                    const targetBinding = resolvedBinding ?? binding;
+                    return targetBinding ? this.options.backendResolver?.(targetBinding) : undefined;
+                },
+                resolveFilesystemBackend: (resolvedBinding) => {
+                    const targetBinding = resolvedBinding ?? binding;
+                    return targetBinding ? this.resolveFilesystemBackend(targetBinding) : undefined;
+                },
                 resolveCustom: this.options.declaredMiddlewareResolver,
                 binding,
             })),
@@ -625,7 +738,12 @@ export class AgentRuntimeAdapter {
             interruptOn: this.resolveInterruptOn(binding),
             name: params.name,
             memory: params.memory,
-            skills: params.skills,
+            skills: await materializeDeepAgentSkillSourcePaths({
+                workspaceRoot: binding.harnessRuntime.workspaceRoot,
+                runRoot: binding.harnessRuntime.runRoot,
+                ownerId: binding.agent.id,
+                skillPaths: params.skills,
+            }),
             generalPurposeAgent: params.generalPurposeAgent,
             taskDescription: params.taskDescription,
         };
@@ -660,7 +778,7 @@ export class AgentRuntimeAdapter {
     }
     async invoke(binding, input, threadId, runId, resumePayload, history = [], options = {}) {
         const request = resumePayload === undefined
-            ? this.buildInvocationRequest(history, input, options)
+            ? this.buildInvocationRequest(binding, history, input, options)
             : new Command({ resume: resumePayload });
         let result;
         try {
@@ -673,7 +791,7 @@ export class AgentRuntimeAdapter {
             }
             const retriedBinding = this.applyStrictToolJsonInstruction(binding);
             const runnable = await this.create(retriedBinding);
-            result = (await this.withTimeout(() => runnable.invoke(this.buildInvocationRequest(history, input, options), { configurable: { thread_id: threadId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(retriedBinding), "agent invoke", "invoke"));
+            result = (await this.withTimeout(() => runnable.invoke(this.buildInvocationRequest(retriedBinding, history, input, options), { configurable: { thread_id: threadId }, ...(options.context ? { context: options.context } : {}) }), this.resolveBindingTimeout(retriedBinding), "agent invoke", "invoke"));
         }
         const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
         const extractedOutput = extractVisibleOutput(result);
@@ -729,7 +847,7 @@ export class AgentRuntimeAdapter {
                 // agent loop and only adds an extra model round-trip before the runnable path.
                 if (canUseDirectModelStream && typeof model.stream === "function") {
                     let emitted = false;
-                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
+                    const stream = await this.withTimeout(() => model.stream(this.buildRawModelMessages(binding, getBindingSystemPrompt(binding), history, input)), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "model stream start", "stream");
                     for await (const chunk of this.iterateWithTimeout(stream, streamIdleTimeoutMs, "model stream", streamDeadlineAt, invokeTimeoutMs)) {
                         const delta = readStreamDelta(chunk);
                         if (delta) {
@@ -748,7 +866,7 @@ export class AgentRuntimeAdapter {
                 }
             }
             const runnable = await this.create(binding);
-            const request = this.buildInvocationRequest(history, input, options);
+            const request = this.buildInvocationRequest(binding, history, input, options);
             if (typeof runnable.streamEvents === "function") {
                 const events = await this.withTimeout(() => runnable.streamEvents(request, { configurable: { thread_id: threadId }, version: "v2", ...(options.context ? { context: options.context } : {}) }), computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs), "agent streamEvents start", "stream");
                 const allowVisibleStreamDeltas = isLangChainBinding(binding);

package/dist/runtime/declared-middleware.d.ts

@@ -3,12 +3,17 @@ type MiddlewareConfig = Record<string, unknown>;
 type MiddlewareFactoryContext = {
     config: MiddlewareConfig;
     resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveBackend?: () => unknown;
+    resolveFilesystemBackend?: () => unknown;
+    binding?: CompiledAgentBinding;
 };
 type MiddlewareFactory = (context: MiddlewareFactoryContext) => Promise<unknown | unknown[] | null | undefined>;
 export declare const DECLARATIVE_MIDDLEWARE_REGISTRY: Record<string, MiddlewareFactory>;
 export declare const SUPPORTED_DECLARATIVE_MIDDLEWARE_KINDS: readonly string[];
 export declare function resolveDeclaredMiddleware(middlewareConfigs: unknown[] | undefined, options: {
     resolveModel: (model: CompiledModel) => Promise<unknown>;
+    resolveBackend?: (binding?: CompiledAgentBinding) => unknown;
+    resolveFilesystemBackend?: (binding?: CompiledAgentBinding) => unknown;
     resolveCustom?: (input: {
         kind: string;
         config: Record<string, unknown>;

package/dist/runtime/declared-middleware.js

@@ -1,4 +1,5 @@
-import { anthropicPromptCachingMiddleware, contextEditingMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, summarizationMiddleware, todoListMiddleware, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, } from "langchain";
+import { anthropicPromptCachingMiddleware, contextEditingMiddleware, dynamicSystemPromptMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, summarizationMiddleware, todoListMiddleware, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, } from "langchain";
+import { createFilesystemMiddleware, createPatchToolCallsMiddleware, createSummarizationMiddleware as createDeepAgentSummarizationMiddleware, } from "deepagents";
 function asMiddlewareConfig(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : null;
 }
@@ -26,6 +27,18 @@ async function resolveReferencedModelList(values, options) {
     return Promise.all(values.map((value) => resolveReferencedModel(value, options)));
 }
 async function createSummarizationMiddleware({ config, resolveModel }) {
+    if (config.provider === "deepagents") {
+        const runtimeConfig = { ...config };
+        runtimeConfig.model = await resolveReferencedModel(runtimeConfig.model, { resolveModel });
+        if (runtimeConfig.model === undefined) {
+            throw new Error("deepagents summarization middleware requires model or modelRef");
+        }
+        if (runtimeConfig.backend === undefined) {
+            throw new Error("deepagents summarization middleware requires backend");
+        }
+        delete runtimeConfig.provider;
+        return createDeepAgentSummarizationMiddleware(runtimeConfig);
+    }
     const runtimeConfig = { ...config };
     runtimeConfig.model = await resolveReferencedModel(runtimeConfig.model, { resolveModel });
     if (runtimeConfig.model === undefined) {
@@ -33,6 +46,17 @@ async function createSummarizationMiddleware({ config, resolveModel }) {
     }
     return summarizationMiddleware(runtimeConfig);
 }
+async function createBindingAwareSummarizationMiddleware(context) {
+    const runtimeConfig = { ...context.config };
+    if (context.binding?.agent.executionMode === "deepagent") {
+        runtimeConfig.provider = "deepagents";
+        runtimeConfig.backend ??= context.resolveBackend?.() ?? context.resolveFilesystemBackend?.();
+    }
+    return createSummarizationMiddleware({
+        ...context,
+        config: runtimeConfig,
+    });
+}
 async function createLlmToolSelectorMiddleware({ config, resolveModel }) {
     const runtimeConfig = { ...config };
     runtimeConfig.model = await resolveReferencedModel(runtimeConfig.model, { resolveModel });
@@ -54,8 +78,15 @@ async function createPiiDeclarativeMiddleware({ config }) {
     const { piiType: _piiType, ...piiOptions } = config;
     return piiMiddleware(piiType, piiOptions);
 }
+async function createFilesystemDeclarativeMiddleware({ config, resolveFilesystemBackend }) {
+    const runtimeConfig = { ...config };
+    runtimeConfig.backend ??= resolveFilesystemBackend?.();
+    return createFilesystemMiddleware(runtimeConfig);
+}
 export const DECLARATIVE_MIDDLEWARE_REGISTRY = {
-    summarization: createSummarizationMiddleware,
+    filesystem: createFilesystemDeclarativeMiddleware,
+    patchToolCalls: async () => createPatchToolCallsMiddleware(),
+    summarization: createBindingAwareSummarizationMiddleware,
     llmToolSelector: createLlmToolSelectorMiddleware,
     modelRetry: async ({ config }) => modelRetryMiddleware(config),
     modelFallback: createModelFallbackDeclarativeMiddleware,
@@ -64,10 +95,12 @@ export const DECLARATIVE_MIDDLEWARE_REGISTRY = {
     modelCallLimit: async ({ config }) => modelCallLimitMiddleware(config),
     todoList: async ({ config }) => todoListMiddleware(config),
     contextEditing: async ({ config }) => contextEditingMiddleware(config),
+    dynamicSystemPrompt: async ({ config }) => dynamicSystemPromptMiddleware(config),
     toolEmulator: async ({ config }) => toolEmulatorMiddleware(config),
     humanInTheLoop: async ({ config }) => humanInTheLoopMiddleware(config),
     openAIModeration: async ({ config }) => openAIModerationMiddleware(config),
     pii: createPiiDeclarativeMiddleware,
+    piiRedaction: async ({ config }) => piiRedactionMiddleware(config),
     anthropicPromptCaching: async ({ config }) => anthropicPromptCachingMiddleware(config),
 };
 export const SUPPORTED_DECLARATIVE_MIDDLEWARE_KINDS = Object.freeze(Object.keys(DECLARATIVE_MIDDLEWARE_REGISTRY).sort());
@@ -85,6 +118,9 @@ export async function resolveDeclaredMiddleware(middlewareConfigs, options) {
             const resolvedBuiltin = await registeredFactory({
                 config: runtimeConfig,
                 resolveModel: options.resolveModel,
+                resolveBackend: () => options.resolveBackend?.(options.binding),
+                resolveFilesystemBackend: () => options.resolveFilesystemBackend?.(options.binding),
+                binding: options.binding,
             });
             if (Array.isArray(resolvedBuiltin)) {
                 resolved.push(...resolvedBuiltin);

package/dist/runtime/harness.d.ts

@@ -1,5 +1,7 @@
 import type { ApprovalRecord, HarnessEvent, HarnessStreamItem, MessageContent, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
 import { type ToolMcpServerOptions } from "../mcp.js";
+import { type InventoryAgentRecord, type InventorySkillRecord } from "./inventory.js";
+import type { RequirementAssessmentOptions } from "./skill-requirements.js";
 export declare class AgentHarnessRuntime {
     private readonly workspace;
     private readonly runtimeAdapterOptions;
@@ -53,6 +55,11 @@ export declare class AgentHarnessRuntime {
         runId?: string;
     }): Promise<ApprovalRecord[]>;
     getApproval(approvalId: string): Promise<ApprovalRecord | null>;
+    listAgentSkills(agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
+    describeWorkspaceInventory(options?: RequirementAssessmentOptions): {
+        workspaceRoot: string;
+        agents: InventoryAgentRecord[];
+    };
     private deleteThreadCheckpoints;
     deleteThread(threadId: string): Promise<boolean>;
     createToolMcpServer(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;

package/dist/runtime/harness.js

@@ -16,6 +16,7 @@ import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCh
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
 import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig } from "./support/compiled-binding.js";
+import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./inventory.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -286,6 +287,12 @@ export class AgentHarnessRuntime {
         const approval = await this.persistence.getApproval(approvalId);
         return approval ? this.toPublicApprovalRecord(approval) : null;
     }
+    listAgentSkills(agentId, options = {}) {
+        return listWorkspaceAgentSkills(this.workspace, agentId, options);
+    }
+    describeWorkspaceInventory(options = {}) {
+        return describeWorkspaceInventory(this.workspace, options);
+    }
     async deleteThreadCheckpoints(threadId) {
         const resolver = this.resolvedRuntimeAdapterOptions.checkpointerResolver;
         if (!resolver) {

package/dist/runtime/index.d.ts

@@ -6,6 +6,7 @@ export { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, mainta
 export { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
 export { AgentHarnessRuntime, AgentHarness } from "./harness.js";
 export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./inventory.js";
+export { assessOpenClawRequirements, assessSkillRequirements, } from "./skill-requirements.js";
 export * from "./parsing/index.js";
 export { PolicyEngine } from "./policy-engine.js";
 export { createInMemoryStore, FileBackedStore } from "./store.js";

package/dist/runtime/index.js

@@ -6,6 +6,7 @@ export { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, mainta
 export { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
 export { AgentHarnessRuntime, AgentHarness } from "./harness.js";
 export { describeWorkspaceInventory, findAgentBinding, listAgentSkills, listAgentTools, listAvailableAgents, listSpecialists, } from "./inventory.js";
+export { assessOpenClawRequirements, assessSkillRequirements, } from "./skill-requirements.js";
 export * from "./parsing/index.js";
 export { PolicyEngine } from "./policy-engine.js";
 export { createInMemoryStore, FileBackedStore } from "./store.js";

package/dist/runtime/inventory.d.ts

@@ -1,4 +1,6 @@
 import type { CompiledAgentBinding, WorkspaceBundle } from "../contracts/types.js";
+import type { OpenClawSkillMetadata } from "./support/skill-metadata.js";
+import { type RequirementAssessmentOptions, type SkillRequirementAssessment } from "./skill-requirements.js";
 export type InventoryToolRecord = {
     name: string;
     description: string;
@@ -9,8 +11,11 @@ export type InventorySkillRecord = {
     description?: string;
     license?: string;
     compatibility?: string;
-    metadata?: Record<string, string>;
+    metadata?: Record<string, unknown>;
     allowedTools?: string[];
+    userInvocable?: boolean;
+    openclaw?: OpenClawSkillMetadata;
+    requirements?: SkillRequirementAssessment;
 };
 export type InventoryAgentRecord = {
     id: string;
@@ -21,10 +26,10 @@ export type InventoryAgentRecord = {
 };
 export declare function findAgentBinding(workspace: WorkspaceBundle, agentId: string): CompiledAgentBinding | undefined;
 export declare function listAgentTools(workspace: WorkspaceBundle, agentId: string): InventoryToolRecord[];
-export declare function listAgentSkills(workspace: WorkspaceBundle, agentId: string): InventorySkillRecord[];
-export declare function listSpecialists(workspace: WorkspaceBundle): InventoryAgentRecord[];
-export declare function listAvailableAgents(workspace: WorkspaceBundle): InventoryAgentRecord[];
-export declare function describeWorkspaceInventory(workspace: WorkspaceBundle): {
+export declare function listAgentSkills(workspace: WorkspaceBundle, agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
+export declare function listSpecialists(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): InventoryAgentRecord[];
+export declare function listAvailableAgents(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): InventoryAgentRecord[];
+export declare function describeWorkspaceInventory(workspace: WorkspaceBundle, options?: RequirementAssessmentOptions): {
     workspaceRoot: string;
     agents: InventoryAgentRecord[];
 };

package/dist/runtime/inventory.js

@@ -1,5 +1,7 @@
 import { readSkillMetadata } from "./support/skill-metadata.js";
 import { getBindingPrimaryTools } from "./support/compiled-binding.js";
+import { assessSkillRequirements, } from "./skill-requirements.js";
+import { createRuntimeEnv } from "./support/runtime-env.js";
 function listHostBindings(workspace) {
     return Array.from(workspace.bindings.values()).filter((binding) => binding.harnessRuntime.hostFacing);
 }
@@ -13,7 +15,36 @@ function dedupeTools(tools) {
     }
     return Array.from(deduped.values());
 }
-function toSkillRecords(skillPaths) {
+function readBackendRequirementOptions(binding) {
+    const backend = binding.deepAgentParams?.backend && typeof binding.deepAgentParams.backend === "object"
+        ? binding.deepAgentParams.backend
+        : undefined;
+    if (!backend) {
+        return {};
+    }
+    const backendState = typeof backend.state === "object" && backend.state
+        ? backend.state
+        : backend;
+    const env = typeof backendState.env === "object" && backendState.env
+        ? Object.fromEntries(Object.entries(backendState.env).filter((entry) => typeof entry[1] === "string"))
+        : undefined;
+    const inheritedEnv = backendState.inheritEnv === false ? {} : process.env;
+    const runtimeEnv = createRuntimeEnv(env, inheritedEnv);
+    return {
+        env: runtimeEnv,
+        path: runtimeEnv.PATH,
+    };
+}
+function mergeRequirementOptions(binding, options = {}) {
+    const fromBackend = readBackendRequirementOptions(binding);
+    return {
+        ...fromBackend,
+        ...options,
+        env: options.env ? { ...(fromBackend.env ?? {}), ...options.env } : fromBackend.env,
+        path: options.path ?? fromBackend.path,
+    };
+}
+function toSkillRecords(skillPaths, options = {}) {
     return Array.from(new Set(skillPaths)).map((skillPath) => {
         const metadata = readSkillMetadata(skillPath);
         return {
@@ -24,6 +55,9 @@ function toSkillRecords(skillPaths) {
             compatibility: metadata.compatibility,
             metadata: metadata.metadata,
             allowedTools: metadata.allowedTools,
+            userInvocable: metadata.userInvocable,
+            openclaw: metadata.openclaw,
+            requirements: assessSkillRequirements(metadata, options),
         };
     });
 }
@@ -34,38 +68,42 @@ export function listAgentTools(workspace, agentId) {
     }
     return dedupeTools(getBindingPrimaryTools(binding));
 }
-export function listAgentSkills(workspace, agentId) {
+export function listAgentSkills(workspace, agentId, options = {}) {
     const binding = findAgentBinding(workspace, agentId);
     if (!binding) {
         return [];
     }
-    return toSkillRecords(binding.deepAgentParams?.skills ?? []);
+    const resolvedOptions = mergeRequirementOptions(binding, options);
+    return toSkillRecords(binding.deepAgentParams?.skills ?? binding.langchainAgentParams?.skills ?? [], resolvedOptions);
 }
-function describeSubagent(subagent) {
+function describeSubagent(subagent, options = {}) {
     return {
         id: subagent.name,
         description: subagent.description,
         role: "specialist",
         tools: dedupeTools(subagent.tools ?? []),
-        skills: toSkillRecords(subagent.skills ?? []),
+        skills: toSkillRecords(subagent.skills ?? [], options),
     };
 }
-export function listSpecialists(workspace) {
-    return listHostBindings(workspace).flatMap((binding) => (binding.deepAgentParams?.subagents ?? []).map(describeSubagent));
+export function listSpecialists(workspace, options = {}) {
+    return listHostBindings(workspace).flatMap((binding) => {
+        const resolvedOptions = mergeRequirementOptions(binding, options);
+        return (binding.deepAgentParams?.subagents ?? []).map((subagent) => describeSubagent(subagent, resolvedOptions));
+    });
 }
-export function listAvailableAgents(workspace) {
+export function listAvailableAgents(workspace, options = {}) {
     const topLevel = listHostBindings(workspace).map((binding) => ({
         id: binding.agent.id,
         description: binding.agent.description,
         role: "host",
         tools: listAgentTools(workspace, binding.agent.id),
-        skills: listAgentSkills(workspace, binding.agent.id),
+        skills: listAgentSkills(workspace, binding.agent.id, options),
     }));
-    return [...topLevel, ...listSpecialists(workspace)];
+    return [...topLevel, ...listSpecialists(workspace, options)];
 }
-export function describeWorkspaceInventory(workspace) {
+export function describeWorkspaceInventory(workspace, options = {}) {
     return {
         workspaceRoot: workspace.workspaceRoot,
-        agents: listAvailableAgents(workspace),
+        agents: listAvailableAgents(workspace, options),
     };
 }

package/dist/runtime/skill-requirements.d.ts

@@ -0,0 +1,27 @@
+import type { OpenClawSkillMetadata, SkillMetadata } from "./support/skill-metadata.js";
+export type RequirementStatus = "satisfied" | "missing" | "unknown";
+export type RequirementCheckRecord = {
+    name: string;
+    status: RequirementStatus;
+};
+export type OpenClawRequirementAssessment = {
+    ready: boolean;
+    missing: boolean;
+    unknown: boolean;
+    bins: RequirementCheckRecord[];
+    anyBins: RequirementCheckRecord[];
+    env: RequirementCheckRecord[];
+    config: RequirementCheckRecord[];
+    primaryEnv?: RequirementCheckRecord;
+};
+export type SkillRequirementAssessment = {
+    openclaw?: OpenClawRequirementAssessment;
+};
+export type RequirementAssessmentOptions = {
+    env?: Record<string, string | undefined>;
+    path?: string;
+    availableBins?: string[];
+    config?: Record<string, unknown> | string[];
+};
+export declare function assessOpenClawRequirements(metadata: OpenClawSkillMetadata | undefined, options?: RequirementAssessmentOptions): OpenClawRequirementAssessment | undefined;
+export declare function assessSkillRequirements(metadata: SkillMetadata, options?: RequirementAssessmentOptions): SkillRequirementAssessment;