@aid-framework/runtime 0.0.0-stage → 0.1.39

package/dist/agents/engine.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The agent-engine seam: which backend runs an agent, and on exactly which release.
+ *
+ * Deep Agents is an *orchestration backend* selected per agent, never the IR, never the
+ * gateway, and never the only implementation. `native` stays the default.
+ *
+ * **The pin.** {@link DEEPAGENTS_PIN} is the single authoritative record of the Deep
+ * Agents release this runtime was built and measured against. It is a bare constant rather
+ * than a range because a range is the thing pinning exists to prevent: the harness's
+ * middleware stack, its recursion accounting and its interrupt payload all move between
+ * releases, so an unpinned backend would change behaviour under a stored eval baseline.
+ * {@link checkEngine} compares the IR's `engineVersion` against *this* constant, not
+ * against whatever package happens to be importable.
+ *
+ * **Per-runtime pins.** The npm harness and the Python harness do not share version
+ * numbers: this runtime pins `deepagents@1.16.0`, the Python runtime pins
+ * `deepagents==0.7.32`. One `engineVersion` therefore cannot satisfy both, and it is not
+ * asked to. Each runtime compares the declaration against its own pin, so a spec versioned
+ * for Python is refused here with {@link DeepAgentsVersionMismatchError} -- honestly, at
+ * the seam that would have to run it -- rather than being waved through on a major-version
+ * match. Accepting any installed release would recreate exactly the silent-drift hole the
+ * pin exists to close.
+ *
+ * **Fail closed, in one place.** Every reason a `deepagents` agent cannot run -- unknown
+ * engine, transfer declared, mismatched pin, missing package -- is raised from
+ * {@link checkEngine}. Putting them together means there is one function to read to know
+ * whether an engine is supported, and no second path that could grow a silent fallback to
+ * the native loop. A runtime that quietly ran a `deepagents` agent on the native engine
+ * would leave `engine` in the IR meaning nothing at all.
+ *
+ * **The backend.** This runtime runs `deepagents` agents through the real npm harness; see
+ * `./deep_agents.ts`. The harness is an optional peer dependency, because an application
+ * that never names `engine: deepagents` should not install a LangChain tree. That makes
+ * {@link installedDeepagentsVersion} load-bearing: it is what turns "the package is absent"
+ * into {@link DeepAgentsUnavailableError} instead of an unresolvable import.
+ */
+import type { AgentDefinition } from './ir.js';
+/** The default engine, and the one every agent that names none keeps using. */
+export declare const NATIVE = "native";
+/** The Deep Agents backend. */
+export declare const DEEPAGENTS = "deepagents";
+/** The closed set of engines the IR may name. */
+export declare const ENGINES: ReadonlySet<string>;
+/**
+ * The one authoritative pin. Measured from the npm registry and mirrored in this
+ * package's `peerDependenciesMeta`; compared against the IR's `engineVersion` at run time.
+ */
+export declare const DEEPAGENTS_PIN = "1.16.0";
+/**
+ * The harness and every required peer, at the exact releases this runtime was measured
+ * against. `deepagents@1.16.0` declares each of these as a peer, so an application that
+ * opts into the backend has to satisfy all of them; spelling them out means the install
+ * instruction in the error message is the one that was actually tested.
+ */
+export declare const DEEPAGENTS_PEERS: readonly string[];
+/** The optional peer set that installs the harness, as one `npm install` argument list. */
+export declare const DEEPAGENTS_EXTRA: string;
+/** The distribution the peers install. */
+export declare const DEEPAGENTS_DISTRIBUTION = "deepagents";
+/**
+ * How {@link installedDeepagentsVersion} finds the harness.
+ *
+ * A seam rather than a bare import so the absent-harness branch is reachable in a test that
+ * has the package installed -- the alternative is uninstalling it, which no hermetic test
+ * can do. It is also what the native-default test observes to prove the runtime never goes
+ * looking for the harness at all when the engine is `native`.
+ */
+export type VersionDetector = () => string | undefined;
+/**
+ * The installed `deepagents` version, or `undefined` when the package is absent.
+ *
+ * `detect` exists so a test can exercise the absent branch without uninstalling anything;
+ * production callers pass nothing.
+ */
+export declare function installedDeepagentsVersion(detect?: VersionDetector): string | undefined;
+/**
+ * Validate this agent's engine, or raise the reason it cannot run.
+ *
+ * Returns the validated engine name. `native` always passes, and passes *before* any
+ * version detection: an agent that does not opt in must never pay for, or even look for,
+ * the harness. `deepagents` passes only when it declares no handoffs, pins
+ * `engineVersion` to the version this runtime is built for, and the package is installed.
+ */
+export declare function checkEngine(agent: AgentDefinition, detect?: VersionDetector): string;
+//# sourceMappingURL=engine.d.ts.map

package/dist/agents/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/agents/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAWH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,+EAA+E;AAC/E,eAAO,MAAM,MAAM,WAAW,CAAC;AAE/B,+BAA+B;AAC/B,eAAO,MAAM,UAAU,eAAe,CAAC;AAEvC,iDAAiD;AACjD,eAAO,MAAM,OAAO,EAAE,WAAW,CAAC,MAAM,CAAiC,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc,WAAW,CAAC;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAQ7C,CAAC;AAEF,2FAA2F;AAC3F,eAAO,MAAM,gBAAgB,QAA6B,CAAC;AAE3D,0CAA0C;AAC1C,eAAO,MAAM,uBAAuB,eAAe,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,MAAM,GAAG,SAAS,CAAC;AAuBvD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,GAAE,eAAsC,GAC7C,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,eAAe,EACtB,MAAM,GAAE,eAAsC,GAC7C,MAAM,CAqBR"}

package/dist/agents/engine.js

@@ -0,0 +1,129 @@
+/**
+ * The agent-engine seam: which backend runs an agent, and on exactly which release.
+ *
+ * Deep Agents is an *orchestration backend* selected per agent, never the IR, never the
+ * gateway, and never the only implementation. `native` stays the default.
+ *
+ * **The pin.** {@link DEEPAGENTS_PIN} is the single authoritative record of the Deep
+ * Agents release this runtime was built and measured against. It is a bare constant rather
+ * than a range because a range is the thing pinning exists to prevent: the harness's
+ * middleware stack, its recursion accounting and its interrupt payload all move between
+ * releases, so an unpinned backend would change behaviour under a stored eval baseline.
+ * {@link checkEngine} compares the IR's `engineVersion` against *this* constant, not
+ * against whatever package happens to be importable.
+ *
+ * **Per-runtime pins.** The npm harness and the Python harness do not share version
+ * numbers: this runtime pins `deepagents@1.16.0`, the Python runtime pins
+ * `deepagents==0.7.32`. One `engineVersion` therefore cannot satisfy both, and it is not
+ * asked to. Each runtime compares the declaration against its own pin, so a spec versioned
+ * for Python is refused here with {@link DeepAgentsVersionMismatchError} -- honestly, at
+ * the seam that would have to run it -- rather than being waved through on a major-version
+ * match. Accepting any installed release would recreate exactly the silent-drift hole the
+ * pin exists to close.
+ *
+ * **Fail closed, in one place.** Every reason a `deepagents` agent cannot run -- unknown
+ * engine, transfer declared, mismatched pin, missing package -- is raised from
+ * {@link checkEngine}. Putting them together means there is one function to read to know
+ * whether an engine is supported, and no second path that could grow a silent fallback to
+ * the native loop. A runtime that quietly ran a `deepagents` agent on the native engine
+ * would leave `engine` in the IR meaning nothing at all.
+ *
+ * **The backend.** This runtime runs `deepagents` agents through the real npm harness; see
+ * `./deep_agents.ts`. The harness is an optional peer dependency, because an application
+ * that never names `engine: deepagents` should not install a LangChain tree. That makes
+ * {@link installedDeepagentsVersion} load-bearing: it is what turns "the package is absent"
+ * into {@link DeepAgentsUnavailableError} instead of an unresolvable import.
+ */
+import { createRequire } from 'node:module';
+import { AgentHandoffUnsupportedError, ConfigurationError, DeepAgentsUnavailableError, DeepAgentsVersionMismatchError, } from '../errors.js';
+import { repr } from '../internal/json.js';
+/** The default engine, and the one every agent that names none keeps using. */
+export const NATIVE = 'native';
+/** The Deep Agents backend. */
+export const DEEPAGENTS = 'deepagents';
+/** The closed set of engines the IR may name. */
+export const ENGINES = new Set([NATIVE, DEEPAGENTS]);
+/**
+ * The one authoritative pin. Measured from the npm registry and mirrored in this
+ * package's `peerDependenciesMeta`; compared against the IR's `engineVersion` at run time.
+ */
+export const DEEPAGENTS_PIN = '1.16.0';
+/**
+ * The harness and every required peer, at the exact releases this runtime was measured
+ * against. `deepagents@1.16.0` declares each of these as a peer, so an application that
+ * opts into the backend has to satisfy all of them; spelling them out means the install
+ * instruction in the error message is the one that was actually tested.
+ */
+export const DEEPAGENTS_PEERS = [
+    'deepagents@1.16.0',
+    'langchain@1.5.10',
+    '@langchain/core@1.2.14',
+    '@langchain/langgraph@1.5.3',
+    '@langchain/langgraph-sdk@1.12.8',
+    '@langchain/langgraph-checkpoint@1.2.1',
+    'langsmith@0.9.0',
+];
+/** The optional peer set that installs the harness, as one `npm install` argument list. */
+export const DEEPAGENTS_EXTRA = DEEPAGENTS_PEERS.join(' ');
+/** The distribution the peers install. */
+export const DEEPAGENTS_DISTRIBUTION = 'deepagents';
+const requireFromHere = createRequire(import.meta.url);
+/**
+ * Read the installed harness version from its own manifest.
+ *
+ * `deepagents/package.json` rather than the module entry point: the manifest is not behind
+ * an `exports` guard, and reading it means detection never loads 3 MB of LangChain just to
+ * answer a version question.
+ */
+function readInstalledVersion() {
+    let manifest;
+    try {
+        manifest = requireFromHere('deepagents/package.json');
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof manifest !== 'object' || manifest === null)
+        return undefined;
+    const version = manifest.version;
+    return typeof version === 'string' ? version : undefined;
+}
+/**
+ * The installed `deepagents` version, or `undefined` when the package is absent.
+ *
+ * `detect` exists so a test can exercise the absent branch without uninstalling anything;
+ * production callers pass nothing.
+ */
+export function installedDeepagentsVersion(detect = readInstalledVersion) {
+    return detect();
+}
+/**
+ * Validate this agent's engine, or raise the reason it cannot run.
+ *
+ * Returns the validated engine name. `native` always passes, and passes *before* any
+ * version detection: an agent that does not opt in must never pay for, or even look for,
+ * the harness. `deepagents` passes only when it declares no handoffs, pins
+ * `engineVersion` to the version this runtime is built for, and the package is installed.
+ */
+export function checkEngine(agent, detect = readInstalledVersion) {
+    if (agent.engine === NATIVE)
+        return NATIVE;
+    if (agent.engine !== DEEPAGENTS) {
+        throw new ConfigurationError(`agent ${repr(agent.id)} declares engine ${repr(agent.engine)}; the IR admits ` +
+            `[${[...ENGINES]
+                .sort()
+                .map((engine) => repr(engine))
+                .join(', ')}]`);
+    }
+    if (agent.handoffs.length > 0) {
+        throw new AgentHandoffUnsupportedError(agent.id, agent.handoffs, DEEPAGENTS);
+    }
+    if (agent.engineVersion !== DEEPAGENTS_PIN) {
+        throw new DeepAgentsVersionMismatchError(agent.id, agent.engineVersion, DEEPAGENTS_PIN);
+    }
+    if (detect() === undefined) {
+        throw new DeepAgentsUnavailableError(DEEPAGENTS_EXTRA, DEEPAGENTS_DISTRIBUTION);
+    }
+    return DEEPAGENTS;
+}
+//# sourceMappingURL=engine.js.map

package/dist/agents/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../src/agents/engine.ts"],"names":[],"mappings":"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"}

package/dist/agents/gateway_chat_model.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Expose {@link ModelGateway} as a LangChain chat model.
+ *
+ * This module is the load-bearing part of the Deep Agents backend. A harness handed a
+ * provider would keep working while silently dropping every guarantee the gateway exists
+ * to provide: the fallback chain, the budget preflight, the cost ledger and the
+ * per-attempt LLM span. The agent would look fine and the budget would stop applying. So
+ * the harness is never handed a provider -- it is handed *this adapter*, and every model
+ * call inside the graph goes back out through our gateway.
+ *
+ * What the adapter is responsible for:
+ *
+ * - **Translation, both directions.** LangChain messages to our {@link Message}, and our
+ *   {@link CompletionResponse} back to an `AIMessage` carrying tool calls, `usage_metadata`
+ *   and the alias/cost the gateway actually charged. The alias matters: a fallback means
+ *   the answer did not come from the pinned model, and the response says so rather than
+ *   letting the harness believe otherwise.
+ * - **Tool filtering.** `bindTools` is the single funnel every tool reaches the model
+ *   through, which makes it the one place to enforce what the agent may call. Deep Agents
+ *   bundles `ls`/`read_file`/`write_file`/`edit_file`/`delete`/`glob`/`grep`/`execute` and
+ *   binds all of them; the allow-list drops everything the agent did not declare, so the
+ *   filesystem and shell tools are unreachable rather than merely undocumented.
+ * - **Budget continuity.** The agent's ceiling travels with every call, so a breach
+ *   surfaces as the gateway's own {@link BudgetExceededError} from inside the harness.
+ *   There is no second accounting path here to disagree with it.
+ *
+ * Everything in here statically imports `@langchain/*`. That is deliberate and safe: the
+ * harness is optional for consumers, `agents/deep_agents.ts` is the only module that
+ * reaches this one, and it does so with a dynamic `import()` after {@link checkEngine} has
+ * proved the packages are installed.
+ */
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { BaseChatModelCallOptions, BindToolsInput } from '@langchain/core/language_models/chat_models';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
+import { z } from 'zod';
+import type { Budget } from '../cost.js';
+import type { ModelGateway } from '../gateway.js';
+import type { GenerationResult } from '../types.js';
+import { Message, ToolDefinition } from '../types.js';
+/** What {@link harnessTool} needs to build one harness tool around our executor. */
+export interface HarnessToolSpec {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, unknown>;
+    /** Run the call through the native loop's executor and return the observation. */
+    readonly call: (args: Record<string, unknown>) => Promise<string>;
+}
+/**
+ * A LangChain chat model whose every generation is a gateway call.
+ *
+ * Construct it with the alias the IR pinned, the gateway that owns fallback and
+ * accounting, and the ceiling this agent may spend. `allowedTools` is the tool allow-list:
+ * `undefined` admits everything the harness binds, which is only appropriate for an agent
+ * that declares no tools.
+ */
+export declare class GatewayChatModel extends BaseChatModel {
+    readonly gateway: ModelGateway;
+    readonly alias: string;
+    readonly fallbacks: readonly string[];
+    readonly budget: Budget | undefined;
+    readonly allowedTools: ReadonlySet<string> | undefined;
+    /**
+     * The agent's `maxSteps`, counted in model calls. Enforced here because this adapter is
+     * the only place that sees every model call -- and because the harness's own limiter
+     * *completes* the run with a synthetic answer instead of failing.
+     */
+    readonly maxCalls: number | undefined;
+    /** What `bindTools` last admitted. Read by tests, never by the harness. */
+    readonly boundTools: readonly ToolDefinition[];
+    /** Every generation this model produced, in order: proof the harness went through us. */
+    readonly calls: GenerationResult[];
+    constructor(init: {
+        readonly gateway: ModelGateway;
+        readonly alias: string;
+        readonly fallbacks?: readonly string[];
+        readonly budget?: Budget;
+        readonly allowedTools?: ReadonlySet<string>;
+        readonly maxCalls?: number;
+        readonly boundTools?: readonly ToolDefinition[];
+        readonly calls?: GenerationResult[];
+    });
+    /**
+     * Admit only the tools this agent declared.
+     *
+     * Every tool the harness offers -- bundled ones included -- arrives here, so an
+     * allow-list applied at this point is the difference between "we do not document a
+     * shell" and "there is no shell the model can reach". The filtered set is kept on a copy
+     * rather than on `this` so two agents sharing one adapter cannot widen each other's
+     * grant; the copy shares `calls`, because the accumulator is the run's spend record and a
+     * per-copy one would silently lose the generations of every bound model.
+     */
+    bindTools(tools: BindToolsInput[]): GatewayChatModel;
+    _llmType(): string;
+    _identifyingParams(): Record<string, unknown>;
+    /**
+     * One harness model call, routed through the gateway.
+     *
+     * LangChain 1.x exposes a single async generation hook: `generate` and `invoke` both
+     * return promises and there is no synchronous entry point at all, so unlike the Python
+     * adapter there is no second path to refuse here.
+     *
+     * `fallbacks` and `budget` travel with the call, so the harness gets the same fallback
+     * behaviour and the same hard ceiling as the native loop. A breach is raised, not
+     * returned: the harness must not be able to continue past a budget the ledger refused.
+     */
+    _generate(messages: BaseMessage[], _options: BaseChatModelCallOptions, _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    _streamResponseChunks(_messages: BaseMessage[], _options: BaseChatModelCallOptions, _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+/**
+ * Translate the harness transcript into ours.
+ *
+ * Tool calls and their ids are preserved verbatim: the harness pairs a result with its
+ * call by id, and renaming or renumbering them here would break the pairing in a way that
+ * only shows up as a tool result attached to the wrong call.
+ */
+export declare function toAidMessages(messages: readonly BaseMessage[]): Message[];
+/**
+ * Normalise the harness's tool specs and drop everything outside the grant.
+ *
+ * The harness offers OpenAI-shaped objects, bare `{name, parameters}` records, and
+ * `BaseTool` instances carrying a Zod schema. All are accepted so the allow-list cannot be
+ * bypassed by a shape the filter did not recognise: anything unparseable has no name, and
+ * a tool with no name is refused rather than passed through.
+ */
+export declare function toToolDefinitions(tools: readonly BindToolsInput[], options?: {
+    readonly allowed?: ReadonlySet<string> | undefined;
+}): ToolDefinition[];
+/**
+ * Translate our transcript back out, for seeding the harness with prior turns.
+ *
+ * This exists so a resumed run hands the harness the same transcript the native loop would
+ * have, rather than a summary of it. Tool calls are re-emitted as `AIMessage.tool_calls` so
+ * the harness sees them as calls it can pair, which is what keeps a resumed run's
+ * transcript comparable to an uninterrupted one.
+ */
+export declare function toLangchainMessages(messages: readonly Message[]): BaseMessage[];
+/**
+ * Wrap one declared tool as a harness tool whose body is our executor.
+ *
+ * The body is deliberately thin: authorization and the tool-call guardrail run in the
+ * guardrail middleware of whichever agent is calling, and execution goes through the same
+ * `ToolExecutor` the native loop uses. That is what makes a tool call under this engine the
+ * same event as one under the native engine.
+ *
+ * The call id is derived, not random: the harness pairs a result with its call by id, and a
+ * random one would make two identical runs differ.
+ */
+export declare function harnessTool(spec: HarnessToolSpec): import("@langchain/core/tools").DynamicStructuredTool<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Record<string, unknown>, unknown, string, unknown, string> | import("@langchain/core/tools").DynamicTool<string, unknown>;
+//# sourceMappingURL=gateway_chat_model.d.ts.map

package/dist/agents/gateway_chat_model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway_chat_model.d.ts","sourceRoot":"","sources":["../../src/agents/gateway_chat_model.ts"],"names":[],"mappings":"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"}