@botbotgo/agent-harness 0.0.56 → 0.0.58

package/dist/index.js

@@ -1,2 +1,2 @@
-export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, getApproval, getThread, listApprovals, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getThread, listAgentSkills, listApprovals, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export { tool } from "./tools.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.55";
+export declare const AGENT_HARNESS_VERSION = "0.0.57";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.55";
+export const AGENT_HARNESS_VERSION = "0.0.57";

package/dist/resource/resource-impl.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { stat } from "node:fs/promises";
@@ -12,6 +12,7 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
 import { AGENT_HARNESS_VERSION } from "../package-version.js";
 import { isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
+import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
 import { resolveIsolatedResourceModulePath } from "./isolation.js";
 import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator } from "./sources.js";
 const resourceDir = path.dirname(fileURLToPath(import.meta.url));
@@ -38,6 +39,33 @@ export function resolveLocalResourceProviderEntry(currentResourceDir, resolveIns
     return candidates.at(-1) ?? path.resolve(currentResourceDir, "../../../resource-package/dist/src/index.js");
 }
 const resourceProviderEntry = resolveLocalResourceProviderEntry(resourceDir);
+function listVirtualRootEntries(rootDir) {
+    try {
+        return new Set(readdirSync(rootDir, { withFileTypes: true }).map((entry) => entry.name));
+    }
+    catch {
+        return new Set();
+    }
+}
+function normalizeVirtualExecuteCommand(command, rootDir) {
+    if (typeof command !== "string" || command.length === 0) {
+        return command;
+    }
+    const rootEntries = listVirtualRootEntries(rootDir);
+    if (rootEntries.size === 0) {
+        return command;
+    }
+    return command.replace(/(^|[\s=:(\[{,;|&])(?<quote>["']?)(?<virtualPath>\/(?:[^\s"'`;|&()<>]+))(?:\k<quote>)/g, (match, prefix, quote = "", virtualPath) => {
+        const normalizedVirtualPath = virtualPath.replace(/\/+/g, "/");
+        const segments = normalizedVirtualPath.split("/").filter((segment) => segment.length > 0);
+        const firstSegment = segments[0];
+        if (!firstSegment || !rootEntries.has(firstSegment)) {
+            return match;
+        }
+        const translatedPath = path.resolve(rootDir, ...segments);
+        return `${prefix}${quote}${translatedPath}${quote}`;
+    });
+}
 async function loadLocalResource(entry) {
     if (!existsSync(entry)) {
         return null;
@@ -70,7 +98,11 @@ class CompatibleCompositeBackend {
         const sandboxLike = defaultBackend;
         if (typeof sandboxLike.id === "string" && typeof sandboxLike.execute === "function") {
             this.id = sandboxLike.id;
-            this.execute = (command) => this.composite.execute(command);
+            const virtualCwd = typeof sandboxLike.cwd === "string" && sandboxLike.virtualMode === true ? sandboxLike.cwd : null;
+            this.execute =
+                virtualCwd
+                    ? (command) => this.composite.execute(normalizeVirtualExecuteCommand(command, virtualCwd))
+                    : (command) => this.composite.execute(command);
         }
     }
     lsInfo(filePath) {
@@ -116,6 +148,10 @@ function createInlineBackendResolver(workspace) {
             return workspace.workspaceRoot;
         };
         const createBackend = (kind, config, runtimeLike) => {
+            const configuredEnv = typeof config?.env === "object" && config.env
+                ? Object.fromEntries(Object.entries(config.env).filter((entry) => typeof entry[1] === "string"))
+                : undefined;
+            const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
             switch (kind) {
                 case "LocalShellBackend": {
                     const rootDir = resolveBackendRootDir(config?.rootDir);
@@ -125,9 +161,7 @@ function createInlineBackendResolver(workspace) {
                         virtualMode: config?.virtualMode === true,
                         timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
                         maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
-                        env: typeof config?.env === "object" && config.env
-                            ? Object.fromEntries(Object.entries(config.env).filter((entry) => typeof entry[1] === "string"))
-                            : undefined,
+                        env: createRuntimeEnv(configuredEnv, inheritedEnv),
                         inheritEnv: config?.inheritEnv !== false,
                     });
                 }
@@ -139,9 +173,7 @@ function createInlineBackendResolver(workspace) {
                         virtualMode: config?.virtualMode === false ? false : true,
                         timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
                         maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
-                        env: typeof config?.env === "object" && config.env
-                            ? Object.fromEntries(Object.entries(config.env).filter((entry) => typeof entry[1] === "string"))
-                            : undefined,
+                        env: createRuntimeEnv(configuredEnv, inheritedEnv),
                         inheritEnv: config?.inheritEnv !== false,
                     });
                 }
@@ -318,7 +350,7 @@ export async function getOrCreateMcpClient(config) {
                     : new StdioClientTransport({
                         command: config.command ?? "",
                         args: config.args,
-                        env: config.env,
+                        env: createRuntimeEnv(config.env),
                         cwd: config.cwd,
                     });
         await client.connect(transport);

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -12,6 +12,13 @@ declare class RuntimeOperationTimeoutError extends Error {
     readonly stage: "stream" | "invoke";
     constructor(operation: string, timeoutMs: number, stage?: "stream" | "invoke");
 }
+export declare function relativizeDeepAgentSkillSourcePaths(workspaceRoot: string | undefined, skillPaths: string[] | undefined): string[] | undefined;
+export declare function materializeDeepAgentSkillSourcePaths(options: {
+    workspaceRoot?: string;
+    runRoot?: string;
+    ownerId: string;
+    skillPaths?: string[];
+}): Promise<string[] | undefined>;
 export declare class AgentRuntimeAdapter {
     private readonly options;
     constructor(options?: RuntimeAdapterOptions);
@@ -26,6 +33,7 @@ export declare class AgentRuntimeAdapter {
     private resolveModel;
     private buildToolNameMapping;
     private buildAgentMessages;
+    private buildSlashCommandSkillInstruction;
     private buildInvocationRequest;
     private buildStateSnapshot;
     private buildRawModelMessages;

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;
     }
@@ -572,6 +669,12 @@ 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,
@@ -635,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,
         };
@@ -670,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 {
@@ -683,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);
@@ -739,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) {
@@ -758,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/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;