@botbotgo/agent-harness 0.0.8 → 0.0.10

package/README.md

@@ -0,0 +1,269 @@
+# @botbotgo/agent-harness
+
+`@botbotgo/agent-harness` is a TypeScript framework for running local agent workspaces with declarative config, reusable tools, reusable skills, and configurable host-agent routing.
+
+It is designed for two common use cases:
+
+- build a reusable agent runtime package and publish it to npm
+- build an application workspace that ships its own agents, tools, skills, and model config
+
+The public API stays intentionally small:
+
+- `createAgentHarness(...)`
+- `run(...)`
+- `subscribe(...)`
+- `getThread(...)`
+- `stop(...)`
+
+## Product Overview
+
+Agent Harness loads a workspace from disk, compiles its config into runnable agent bindings, and executes requests through either a lightweight LangChain v1 path or a DeepAgent path.
+
+Out of the box, the framework supports:
+
+- workspace loading from a directory root
+- declarative `Model`, `EmbeddingModel`, `VectorStore`, `LangChainAgent`, `DeepAgent`, and `Runtime` objects
+- host-agent routing between a direct path and an orchestration path
+- tool loading from resource packages and external sources
+- skill discovery from filesystem roots
+- subagent discovery from filesystem roots
+- thread persistence, run history, and resumable state
+
+The default package config in this repo shows the intended model:
+
+- `direct`: low-latency host for simple one-step requests
+- `orchestra`: default host for multi-step work, tools, skills, and delegation
+
+## Quick Start
+
+Install the package:
+
+```bash
+npm install @botbotgo/agent-harness
+```
+
+Create a workspace with at least:
+
+```text
+your-workspace/
+  AGENTS.md
+  config/
+    model.yaml
+    runtime.yaml
+    direct.yaml
+    orchestra.yaml
+```
+
+Minimal usage:
+
+```ts
+import { createAgentHarness, run, stop } from "@botbotgo/agent-harness";
+
+const harness = await createAgentHarness("/absolute/path/to/your-workspace");
+
+try {
+  const result = await run(harness, {
+    agentId: "direct",
+    input: "Summarize what this workspace is for.",
+  });
+
+  console.log(result.output);
+} finally {
+  await stop(harness);
+}
+```
+
+If you want the framework to choose the host agent automatically, pass `agentId: "auto"` when your workspace has runtime routing configured.
+
+## How To Use
+
+There are two common ways to use the framework.
+
+### 1. Use It As A Library
+
+Load a workspace from disk and run requests through the public API.
+
+```ts
+import { createAgentHarness, getThread, run, subscribe, stop } from "@botbotgo/agent-harness";
+
+const harness = await createAgentHarness("/absolute/path/to/workspace");
+
+const unsubscribe = subscribe(harness, (event) => {
+  console.log(event.eventType, event.payload);
+});
+
+try {
+  const firstRun = await run(harness, {
+    agentId: "orchestra",
+    input: "Inspect the workspace and explain the available agents.",
+    listeners: {
+      onChunk(chunk) {
+        process.stdout.write(chunk);
+      },
+    },
+  });
+
+  const thread = await getThread(harness, firstRun.threadId);
+  console.log(thread?.messages.at(-1)?.content);
+} finally {
+  unsubscribe();
+  await stop(harness);
+}
+```
+
+### 2. Use It Inside An App Workspace
+
+The example app in [`examples/stock-research-app`](/Users/boqiang.liang/900-project/agent-harness3/examples/stock-research-app/README.md) is the reference shape for an application workspace. It keeps the framework package separate from app-specific agents, tools, and skills.
+
+Run the example:
+
+```bash
+cd examples/stock-research-app
+npm install
+npm run start -- "Investigate NVDA and produce a balanced stock research brief."
+```
+
+## How To Configure
+
+Agent Harness is workspace-first. The runtime is assembled from files on disk rather than from a large constructor API.
+
+### Core Files
+
+- `AGENTS.md`: durable instructions and operating rules loaded into agent memory where configured
+- `config/model.yaml`: default chat model
+- `config/runtime.yaml`: workspace-wide runtime defaults such as `runRoot` and host routing
+- `config/direct.yaml`: lightweight direct-response host agent
+- `config/orchestra.yaml`: default orchestration host agent
+- `config/embedding-model.yaml`: embeddings preset for retrieval flows
+- `config/vector-store.yaml`: vector store preset for retrieval flows
+
+### Minimal Model Config
+
+```yaml
+apiVersion: agent-harness/v1alpha1
+kind: Model
+metadata:
+  name: default
+spec:
+  provider: ollama
+  model: gpt-oss:latest
+  init:
+    baseUrl: http://localhost:11434
+    temperature: 0.2
+```
+
+### Runtime Routing
+
+`config/runtime.yaml` controls shared runtime behavior. In this repo it defines:
+
+- `runRoot`: where thread state, run artifacts, approvals, and indexes are stored
+- `routing.systemPrompt`: how the harness chooses between the primary and secondary host agents when `agentId: "auto"` is used
+
+### Agent Config
+
+Agent objects are declarative YAML files. The package currently supports:
+
+- `LangChainAgent`
+- `DeepAgent`
+
+Typical fields include:
+
+- `metadata.name`
+- `metadata.description`
+- `spec.modelRef`
+- `spec.systemPrompt`
+- `spec.checkpointer`
+- `spec.memory`
+- `spec.store`
+- `spec.backend`
+
+Use `LangChainAgent` for a fast direct path. Use `DeepAgent` when you need richer orchestration, tool-heavy execution, memory backends, and delegation.
+
+## How To Extend
+
+The extension model is filesystem-based. You extend the harness by adding new config objects, new discovery roots, or new resource packages.
+
+### Add More Agents
+
+Subagents can be discovered from configured roots. The discovery layer supports:
+
+- local filesystem paths
+- external resource sources
+- builtin discovery paths
+
+The harness scans YAML files under the discovered agent roots and adds them to the workspace graph.
+
+### Add Skills
+
+Skills are discovered from roots that contain either:
+
+- a direct `SKILL.md`
+- child directories where each directory contains its own `SKILL.md`
+
+A practical layout looks like this:
+
+```text
+your-workspace/
+  resources/
+    skills/
+      code-review/
+        SKILL.md
+      release-check/
+        SKILL.md
+```
+
+### Add Tools
+
+Tools can come from:
+
+- resource packages
+- external sources
+- builtin resources
+- declarative tool objects that bundle or reference other tools
+
+The example application demonstrates a clean pattern: keep app-specific tools under `resources/tools/` and keep one tool per module.
+
+### Add Retrieval
+
+If your workspace needs RAG-style behavior:
+
+1. add an `EmbeddingModel`
+2. add a `VectorStore`
+3. point retrieval-oriented tools at those refs
+
+This repo already includes `config/embedding-model.yaml` and `config/vector-store.yaml` as the default pattern.
+
+### Extend The Runtime In Code
+
+The public API also accepts a prebuilt `WorkspaceBundle`, which lets you compile or inject workspace data yourself before creating the harness. That path is useful when you need tighter control in tests or in a higher-level product.
+
+## Suggested Workspace Layout
+
+```text
+your-workspace/
+  AGENTS.md
+  config/
+    model.yaml
+    runtime.yaml
+    direct.yaml
+    orchestra.yaml
+    embedding-model.yaml
+    vector-store.yaml
+  resources/
+    agents/
+    skills/
+    tools/
+  .agent/
+```
+
+## Development
+
+Build and test this package locally:
+
+```bash
+npm run build
+npm run check
+npm test
+```
+
+The example workspace under [`examples/stock-research-app`](/Users/boqiang.liang/900-project/agent-harness3/examples/stock-research-app/README.md) is the fastest way to understand how an app should package its own agents, tools, and skills around this framework.

package/dist/config/orchestra.yaml

@@ -39,7 +39,7 @@ spec:
     path: store.json
   # DeepAgents aligned feature: backend config passed into `createDeepAgent({ backend })`.
   # This directly defines the backend topology for this agent:
-  # - runtime graph state uses `StateBackend`
+  # - workspace execution uses a lightweight VFS sandbox
   # - long-term memory under `/memories/*` uses `StoreBackend`
   # - `CompositeBackend` composes those backend instances together
   # The harness also injects a persistent file-backed store and a file-backed checkpointer so that
@@ -48,11 +48,9 @@ spec:
   backend:
     kind: CompositeBackend
     state:
-      # Available state backend `kind` options today: `StateBackend`, `LocalShellBackend`.
-      kind: LocalShellBackend
-      inheritEnv: true
+      # Available state backend `kind` options today: `StateBackend`, `LocalShellBackend`, `VfsSandbox`.
+      kind: VfsSandbox
       timeout: 600
-      maxOutputBytes: 200000
     routes:
       /memories/:
         # Available route backend `kind` options today: `StoreBackend`.

package/dist/contracts/types.d.ts

@@ -57,6 +57,7 @@ export type ParsedToolObject = {
     type: string;
     name: string;
     description: string;
+    implementationName?: string;
     config?: Record<string, unknown>;
     inputSchemaRef?: string;
     backendOperation?: string;
@@ -158,7 +159,8 @@ export type CompiledAgentBinding = {
 };
 export type WorkspaceBundle = {
     workspaceRoot: string;
-    builtinSources: string[];
+    resourceSources: string[];
+    builtinSources?: string[];
     refs: Map<string, WorkspaceObject | ParsedAgentObject>;
     models: Map<string, ParsedModelObject>;
     embeddings: Map<string, ParsedEmbeddingModelObject>;
@@ -169,6 +171,7 @@ export type WorkspaceBundle = {
 };
 export type WorkspaceLoadOptions = {
     overlayRoots?: string[];
+    resourceSources?: string[];
     builtinSources?: string[];
 };
 export type ThreadSummary = {

package/dist/extensions.js

@@ -1,6 +1,6 @@
 import path from "node:path";
-import { builtinSkillsRoot } from "./vendor/builtins.js";
-import { isExternalSourceLocator, resolveExternalSourcePath } from "./vendor/sources.js";
+import { defaultResourceSkillsRoot } from "./resource/resource.js";
+import { isExternalSourceLocator, resolveExternalResourcePath } from "./resource/sources.js";
 const toolKindAdapters = new Map();
 const skillSourceResolvers = new Map();
 const skillInheritancePolicies = new Map();
@@ -217,7 +217,7 @@ registerSkillSourceResolver({
         }
         const candidate = String(skill.sourcePathRef);
         if (isExternalSourceLocator(candidate)) {
-            return [resolveExternalSourcePath(candidate, workspaceRoot)];
+            return [resolveExternalResourcePath(candidate, workspaceRoot)];
         }
         return [candidate.startsWith("/") ? candidate : `${workspaceRoot}/${candidate}`];
     },
@@ -225,7 +225,7 @@ registerSkillSourceResolver({
 registerSkillSourceResolver({
     kind: "builtin",
     resolve({ skill }) {
-        return [path.join(builtinSkillsRoot(), skill.sourcePathRef)];
+        return [path.join(defaultResourceSkillsRoot(), skill.sourcePathRef)];
     },
 });
 registerSkillInheritancePolicy({
@@ -244,7 +244,7 @@ registerSkillPackagingConvention({
     resolve({ workspaceRoot, skill }) {
         const candidate = String(skill.sourcePathRef);
         if (isExternalSourceLocator(candidate)) {
-            return [resolveExternalSourcePath(candidate, workspaceRoot)];
+            return [resolveExternalResourcePath(candidate, workspaceRoot)];
         }
         return [candidate.startsWith("/") ? candidate : `${workspaceRoot}/${candidate}`];
     },

package/dist/resource/builtins.d.ts

@@ -0,0 +1 @@
+export { builtinConfigRoot, builtinSkillsRoot, createBuiltinBackendResolver, createBuiltinToolResolver, ensureBuiltinSources, listBuiltinTools, listBuiltinToolsForSource, resolveLocalBuiltinsEntry, } from "./resource.js";

package/dist/resource/builtins.js

@@ -0,0 +1 @@
+export { builtinConfigRoot, builtinSkillsRoot, createBuiltinBackendResolver, createBuiltinToolResolver, ensureBuiltinSources, listBuiltinTools, listBuiltinToolsForSource, resolveLocalBuiltinsEntry, } from "./resource.js";

package/dist/resource/resource-impl.d.ts

@@ -0,0 +1,30 @@
+import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
+export declare function resolveLocalBuiltinsEntry(currentResourceDir: string, resolveInstalledEntry?: () => string | null): string;
+export type ResourceToolInfo = {
+    toolPath: string;
+    backendOperation: string;
+    name: string;
+    description: string;
+    hitl?: {
+        enabled: boolean;
+        allow: Array<"approve" | "edit" | "reject">;
+    };
+};
+export declare function ensureResourceSources(sources?: string[], workspaceRoot?: string): Promise<void>;
+export declare function defaultResourceSkillsRoot(): string;
+export declare function defaultResourceConfigRoot(): string;
+export declare function listResourceTools(sources?: string[], workspaceRoot?: string): Promise<ResourceToolInfo[]>;
+export declare function listResourceToolsForSource(source: string, workspaceRoot?: string): Promise<ResourceToolInfo[]>;
+export declare function createResourceBackendResolver(workspace: WorkspaceBundle): NonNullable<RuntimeAdapterOptions["backendResolver"]>;
+export declare function createResourceToolResolver(workspace: WorkspaceBundle, options?: {
+    getStore?: (_binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => unknown;
+    getEmbeddingModel?: (embeddingModelRef?: string, _binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => Promise<unknown>;
+    getVectorStore?: (vectorStoreRef?: string, _binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => Promise<unknown>;
+}): NonNullable<RuntimeAdapterOptions["toolResolver"]>;
+export declare const ensureBuiltinSources: typeof ensureResourceSources;
+export declare const builtinSkillsRoot: typeof defaultResourceSkillsRoot;
+export declare const builtinConfigRoot: typeof defaultResourceConfigRoot;
+export declare const listBuiltinTools: typeof listResourceTools;
+export declare const listBuiltinToolsForSource: typeof listResourceToolsForSource;
+export declare const createBuiltinBackendResolver: typeof createResourceBackendResolver;
+export declare const createBuiltinToolResolver: typeof createResourceToolResolver;

package/dist/resource/resource-impl.js

@@ -0,0 +1,250 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator } from "./sources.js";
+const resourceDir = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+function installedBuiltinsEntry() {
+    try {
+        return require.resolve("@botbotgo/agent-harness-builtin");
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveLocalBuiltinsEntry(currentResourceDir, resolveInstalledEntry = installedBuiltinsEntry) {
+    const candidates = [
+        path.resolve(currentResourceDir, "../../../builtins/dist/src/index.js"),
+        path.resolve(currentResourceDir, "../../../agent-harness/packages/builtins/dist/src/index.js"),
+        path.resolve(currentResourceDir, "../../../builtins/src/index.ts"),
+        path.resolve(currentResourceDir, "../../../agent-harness/packages/builtins/src/index.ts"),
+        resolveInstalledEntry(),
+    ].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates.at(-1) ?? path.resolve(currentResourceDir, "../../../agent-harness/packages/builtins/dist/src/index.js");
+}
+const builtinsEntry = resolveLocalBuiltinsEntry(resourceDir);
+async function loadLocalResource(entry) {
+    if (!existsSync(entry)) {
+        return null;
+    }
+    const imported = await import(pathToFileURL(entry).href);
+    return (imported.default ?? imported);
+}
+const localResource = await loadLocalResource(builtinsEntry);
+function listProviderTools(provider) {
+    const rawTools = provider?.listResourceTools?.() ?? provider?.listBuiltinTools?.() ?? [];
+    return rawTools.map((tool) => ({
+        ...tool,
+        toolPath: tool.toolPath ?? tool.builtinPath ?? "",
+    }));
+}
+function createProviderToolResolver(provider, workspace, options) {
+    return (provider?.createResourceToolResolver?.(workspace, options) ??
+        provider?.createBuiltinToolResolver?.(workspace, options));
+}
+function createProviderBackendResolver(provider, workspace) {
+    return (provider?.createResourceBackendResolver?.(workspace) ??
+        provider?.createBuiltinBackendResolver?.(workspace));
+}
+function requireLocalResource(feature) {
+    if (localResource) {
+        return localResource;
+    }
+    throw new Error(`agent-harness optional tool bundle support is unavailable for ${feature}. Install the matching provider package or provide a local sibling checkout.`);
+}
+const remoteResourceCache = new Map();
+async function findPackageRoot(startPath) {
+    let current = path.dirname(startPath);
+    for (;;) {
+        try {
+            await stat(path.join(current, "package.json"));
+            return current;
+        }
+        catch { }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return path.dirname(startPath);
+        }
+        current = parent;
+    }
+}
+const functionToolModuleCache = new Map();
+async function loadFunctionToolModule(tool) {
+    const cacheKey = `${tool.sourcePath}:${tool.implementationName ?? tool.id}`;
+    const cached = functionToolModuleCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const loading = (async () => {
+        const imported = await import(pathToFileURL(tool.sourcePath).href);
+        const implementationName = tool.implementationName ?? tool.id;
+        const invoke = imported[implementationName];
+        const schema = imported[`${implementationName}Schema`];
+        if (typeof invoke !== "function") {
+            throw new Error(`Tool module ${tool.sourcePath} must export function ${implementationName}.`);
+        }
+        if (!schema?.parse) {
+            throw new Error(`Tool module ${tool.sourcePath} must export ${implementationName}Schema as a Zod schema.`);
+        }
+        return { invoke, schema };
+    })();
+    functionToolModuleCache.set(cacheKey, loading);
+    return loading;
+}
+function createFunctionToolResolver(workspace) {
+    const functionTools = new Map(Array.from(workspace.tools.values())
+        .filter((tool) => tool.type === "function" && tool.sourcePath.endsWith(".mjs"))
+        .map((tool) => [tool.id, tool]));
+    return (toolIds) => toolIds.flatMap((toolId) => {
+        const tool = functionTools.get(toolId);
+        if (!tool) {
+            return [];
+        }
+        return [
+            {
+                name: tool.name,
+                description: tool.description,
+                async invoke(input) {
+                    const loaded = await loadFunctionToolModule(tool);
+                    const parsedInput = loaded.schema.parse(input ?? {});
+                    const toolPackageRoot = await findPackageRoot(tool.sourcePath);
+                    return loaded.invoke(parsedInput, {
+                        appRoot: workspace.workspaceRoot,
+                        toolId: tool.id,
+                        toolPath: tool.sourcePath,
+                        toolPackageRoot,
+                    });
+                },
+            },
+        ];
+    });
+}
+function resolvePackageEntry(packageRoot, pkg) {
+    const exportsField = pkg.exports;
+    if (typeof exportsField === "string") {
+        return path.resolve(packageRoot, exportsField);
+    }
+    if (exportsField && typeof exportsField === "object" && "." in exportsField) {
+        const rootExport = exportsField["."];
+        if (typeof rootExport === "string") {
+            return path.resolve(packageRoot, rootExport);
+        }
+        if (rootExport && typeof rootExport === "object") {
+            const importEntry = rootExport.import ?? rootExport.default;
+            if (typeof importEntry === "string") {
+                return path.resolve(packageRoot, importEntry);
+            }
+        }
+    }
+    if (typeof pkg.module === "string") {
+        return path.resolve(packageRoot, pkg.module);
+    }
+    if (typeof pkg.main === "string") {
+        return path.resolve(packageRoot, pkg.main);
+    }
+    return path.resolve(packageRoot, "index.js");
+}
+async function loadRemoteResource(source, workspaceRoot) {
+    const cached = remoteResourceCache.get(source);
+    if (cached !== undefined) {
+        return cached;
+    }
+    if (!isExternalSourceLocator(source)) {
+        throw new Error(`Unsupported resource source ${source}. Use npm:, tgz:, or file:.`);
+    }
+    const parsed = parseExternalSourceLocator(source);
+    if (parsed.subpath) {
+        throw new Error(`Resource source ${source} must point at a package root, not a subpath`);
+    }
+    await ensureExternalResourceSource(source, workspaceRoot);
+    const packageRoot = await ensureExternalSource(source, workspaceRoot);
+    const pkg = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
+    const entry = resolvePackageEntry(packageRoot, pkg);
+    if (!existsSync(entry)) {
+        remoteResourceCache.set(source, null);
+        return null;
+    }
+    const imported = await import(pathToFileURL(entry).href);
+    const provider = (imported.default ?? imported);
+    if (listProviderTools(provider).length === 0 &&
+        !provider.listResourceTools &&
+        !provider.listBuiltinTools) {
+        remoteResourceCache.set(source, null);
+        return null;
+    }
+    if (!provider.createResourceToolResolver && !provider.createBuiltinToolResolver) {
+        remoteResourceCache.set(source, null);
+        return null;
+    }
+    const typedProvider = provider;
+    remoteResourceCache.set(source, typedProvider);
+    return typedProvider;
+}
+export async function ensureResourceSources(sources = [], workspaceRoot = process.cwd()) {
+    await Promise.all(sources.map((source) => loadRemoteResource(source, workspaceRoot)));
+}
+export function defaultResourceSkillsRoot() {
+    const provider = requireLocalResource("default resource skill resolution");
+    return provider.defaultResourceSkillsRoot?.() ?? provider.builtinSkillsRoot?.() ?? "";
+}
+export function defaultResourceConfigRoot() {
+    const provider = requireLocalResource("default resource config resolution");
+    return provider.defaultResourceConfigRoot?.() ?? provider.builtinConfigRoot?.() ?? provider.builtinDefaultsRoot?.() ?? "";
+}
+export async function listResourceTools(sources = [], workspaceRoot = process.cwd()) {
+    await ensureResourceSources(sources, workspaceRoot);
+    const deduped = new Map();
+    for (const tool of listProviderTools(localResource)) {
+        deduped.set(tool.toolPath, tool);
+    }
+    for (const source of sources) {
+        for (const tool of listProviderTools(remoteResourceCache.get(source) ?? undefined)) {
+            deduped.set(tool.toolPath, tool);
+        }
+    }
+    return Array.from(deduped.values());
+}
+export async function listResourceToolsForSource(source, workspaceRoot = process.cwd()) {
+    await ensureResourceSources([source], workspaceRoot);
+    return listProviderTools(remoteResourceCache.get(source) ?? undefined);
+}
+export function createResourceBackendResolver(workspace) {
+    const localResolver = createProviderBackendResolver(localResource, workspace);
+    return (binding) => localResolver?.(binding) ?? [];
+}
+export function createResourceToolResolver(workspace, options = {}) {
+    const functionResolver = createFunctionToolResolver(workspace);
+    const localResolver = createProviderToolResolver(localResource, workspace, options);
+    const remoteResolvers = (workspace.resourceSources ?? workspace.builtinSources ?? [])
+        .map((source) => remoteResourceCache.get(source))
+        .filter((provider) => Boolean(provider))
+        .map((provider) => createProviderToolResolver(provider, workspace, options))
+        .filter((resolver) => Boolean(resolver));
+    return (toolIds, binding) => {
+        const resolved = [
+            ...functionResolver(toolIds, binding),
+            ...(localResolver?.(toolIds, binding) ?? []),
+            ...remoteResolvers.flatMap((resolver) => resolver(toolIds, binding)),
+        ];
+        const deduped = new Map();
+        for (const tool of resolved) {
+            deduped.set(String(tool.name), tool);
+        }
+        return Array.from(deduped.values());
+    };
+}
+export const ensureBuiltinSources = ensureResourceSources;
+export const builtinSkillsRoot = defaultResourceSkillsRoot;
+export const builtinConfigRoot = defaultResourceConfigRoot;
+export const listBuiltinTools = listResourceTools;
+export const listBuiltinToolsForSource = listResourceToolsForSource;
+export const createBuiltinBackendResolver = createResourceBackendResolver;
+export const createBuiltinToolResolver = createResourceToolResolver;

package/dist/resource/resource.d.ts

@@ -0,0 +1 @@
+export { type ResourceToolInfo, ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, ensureBuiltinSources, builtinSkillsRoot, builtinConfigRoot, listBuiltinTools, listBuiltinToolsForSource, createBuiltinBackendResolver, createBuiltinToolResolver, resolveLocalBuiltinsEntry, } from "./resource-impl.js";

package/dist/resource/resource.js

@@ -0,0 +1 @@
+export { ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, ensureBuiltinSources, builtinSkillsRoot, builtinConfigRoot, listBuiltinTools, listBuiltinToolsForSource, createBuiltinBackendResolver, createBuiltinToolResolver, resolveLocalBuiltinsEntry, } from "./resource-impl.js";

package/dist/{vendor → resource}/sources.d.ts

@@ -3,10 +3,13 @@ type ParsedLocator = {
     spec: string;
     subpath?: string;
 };
+export declare function resolveResourcePackageRoot(root: string): string | null;
 export declare function isExternalSourceLocator(value: unknown): boolean;
 export declare function parseExternalSourceLocator(locator: string): ParsedLocator;
 export declare function ensureExternalSource(locator: string, workspaceRoot: string): Promise<string>;
+export declare function ensureExternalResourceSource(locator: string, workspaceRoot: string): Promise<string>;
 export declare function ensureExternalSources(locators: string[], workspaceRoot: string): Promise<void>;
 export declare function resolveExternalSourcePath(locator: string, workspaceRoot: string): string;
+export declare function resolveExternalResourcePath(locator: string, workspaceRoot: string): string;
 export declare function isDirectoryPath(candidate: string): boolean;
 export {};