@rarebit-one/harness-kernel 0.5.1

package/dist/routing/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/routing/types.ts"],"names":[],"mappings":"AA+DA,kDAAkD;AAClD,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IACtC,UAAU,CAAQ;IAE3B,YAAY,UAAkB,EAAE,KAAe;QAC7C,MAAM,YAAY,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAA;QAC3E,KAAK,CAAC,oCAAoC,UAAU,gBAAgB,YAAY,EAAE,CAAC,CAAA;QACnF,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAA;QACpC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;IAC9B,CAAC;CACF"}

package/dist/secrets.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Turn the run payload's resolved secrets into an environment map for the
+ * code-exec primitive. The caller resolves secret VALUES (from its own secret
+ * store) before the run; the kernel treats them as opaque and only ever
+ * forwards them into executed code as environment variables — never logging them.
+ */
+export declare function secretsToEnv(secrets?: Record<string, string>): NodeJS.ProcessEnv;
+//# sourceMappingURL=secrets.d.ts.map

package/dist/secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["../src/secrets.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,MAAM,CAAC,UAAU,CAMpF"}

package/dist/secrets.js

@@ -0,0 +1,14 @@
+/**
+ * Turn the run payload's resolved secrets into an environment map for the
+ * code-exec primitive. The caller resolves secret VALUES (from its own secret
+ * store) before the run; the kernel treats them as opaque and only ever
+ * forwards them into executed code as environment variables — never logging them.
+ */
+export function secretsToEnv(secrets = {}) {
+    const env = {};
+    for (const [key, value] of Object.entries(secrets)) {
+        env[key] = value;
+    }
+    return env;
+}
+//# sourceMappingURL=secrets.js.map

package/dist/secrets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.js","sourceRoot":"","sources":["../src/secrets.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,UAAkC,EAAE;IAC/D,MAAM,GAAG,GAAsB,EAAE,CAAA;IACjC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACnD,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;IAClB,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/dist/tools/metadata.d.ts

@@ -0,0 +1,93 @@
+import type { ToolSpec } from "../providers/types.js";
+import type { Tool } from "./registry.js";
+/**
+ * Generic tool metadata and the projections that narrow it.
+ *
+ * A tool descriptor carries more than a model needs to call it: who may see it,
+ * whether it needs confirmation, whether it can be undone, how long its result
+ * should be kept. None of that belongs in the JSON schema handed to a provider —
+ * so the metadata is rich and the **projection** to a provider is deliberately
+ * lossy.
+ *
+ * The metadata here is only ever *descriptive*. The kernel records that a tool
+ * says `requiresConfirmation`; it never implements a confirmation flow, because
+ * what confirmation means — a modal, a Slack approval, a second agent — is the
+ * application's decision. Same for undo and retention. Policy lives in the app
+ * layer; the vocabulary lives here so every layer agrees on the words.
+ */
+/**
+ * How a turn was invoked. A tool whose surface differs by invocation path
+ * declares the modes it participates in, and resolution filters by the turn's
+ * mode.
+ *
+ *   - `user_initiated`   — a normal user-driven turn.
+ *   - `system_initiated` — a turn fired by a trigger, bypassing the user.
+ */
+export type InvocationMode = "user_initiated" | "system_initiated";
+/** How long a tool's result should be retained by the caller. */
+export type ResultRetention = "ephemeral" | "standard" | "persistent";
+/**
+ * Whether a tool's raw output reaches the client. `suppressed` trims it from
+ * client-facing envelopes while the model still receives it unchanged — for
+ * tools whose output is the model's working data, not a user-facing payload.
+ */
+export type ClientResultVisibility = "full" | "suppressed";
+/**
+ * Optional descriptive metadata on a {@link Tool}. Every field is optional and
+ * an absent field always means "no restriction", so a tool that declares no
+ * metadata behaves exactly as it did before this existed.
+ */
+export interface ToolMetadata {
+    /** Human-facing label, where a UI wants something friendlier than `name`. */
+    displayName?: string;
+    /**
+     * Capability scoping. When set, only the listed capabilities see the tool;
+     * absent or null means every capability does.
+     */
+    targetCapabilities?: string[] | null;
+    /**
+     * Invocation-mode scoping. When set, the tool is visible only in the listed
+     * modes; absent or null means mode-agnostic. A tool that declares modes is
+     * hidden from an unscoped resolution, so a system-only tool can never leak
+     * into a user-driven loop.
+     */
+    invocationModes?: InvocationMode[] | null;
+    /** The caller should confirm with a human before executing. */
+    requiresConfirmation?: boolean;
+    /** The effect can be undone. */
+    reversible?: boolean;
+    /** The tool that undoes this one, when `reversible`. */
+    undoToolName?: string | null;
+    /** How long undo stays available. */
+    undoWindowSeconds?: number | null;
+    resultRetention?: ResultRetention;
+    clientResultVisibility?: ClientResultVisibility;
+}
+/** The scope a tool surface is being resolved for. */
+export interface ToolSelection {
+    /** Resolving capability; matched against `targetCapabilities`. */
+    capability?: string;
+    /** Invocation mode of the turn; matched against `invocationModes`. */
+    mode?: InvocationMode;
+    /** Allowlist of tool names, e.g. from a workflow's permissions. */
+    allowed?: string[];
+}
+/** Whether one tool is visible under a selection. */
+export declare function isToolVisible(tool: Tool, selection?: ToolSelection): boolean;
+/**
+ * Narrow a tool surface to what a given capability and invocation mode may see.
+ * This is the projection that runs *before* the model ever hears about a tool.
+ */
+export declare function selectTools(tools: Tool[], selection?: ToolSelection): Tool[];
+/**
+ * Project tools down to the provider-facing definitions — name, description and
+ * input schema, and nothing else. Everything the metadata adds is intentionally
+ * dropped here: a model has no use for retention policy, and leaking it into
+ * the schema would only spend context.
+ */
+export declare function toToolSpecs(tools: Tool[]): ToolSpec[];
+/** Tools that must not execute until a human has approved them. */
+export declare function toolsRequiringConfirmation(tools: Tool[]): Tool[];
+/** Look up the tool that undoes `name`, when one is declared and reversible. */
+export declare function undoToolFor(tools: Tool[], name: string): Tool | undefined;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/tools/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/tools/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AAEzC;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,kBAAkB,CAAA;AAElE,iEAAiE;AACjE,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,CAAA;AAErE;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,YAAY,CAAA;AAE1D;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;IACpC;;;;;OAKG;IACH,eAAe,CAAC,EAAE,cAAc,EAAE,GAAG,IAAI,CAAA;IACzC,+DAA+D;IAC/D,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,gCAAgC;IAChC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,qCAAqC;IACrC,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,sBAAsB,CAAC,EAAE,sBAAsB,CAAA;CAChD;AAED,sDAAsD;AACtD,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,sEAAsE;IACtE,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CACnB;AAED,qDAAqD;AACrD,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,GAAE,aAAkB,GAAG,OAAO,CAmBhF;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,SAAS,GAAE,aAAkB,GAAG,IAAI,EAAE,CAEhF;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,QAAQ,EAAE,CAErD;AAED,mEAAmE;AACnE,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAEhE;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAIzE"}

package/dist/tools/metadata.js

@@ -0,0 +1,49 @@
+/** Whether one tool is visible under a selection. */
+export function isToolVisible(tool, selection = {}) {
+    const meta = tool.meta;
+    if (selection.allowed && !selection.allowed.includes(tool.spec.name))
+        return false;
+    if (!meta)
+        return true;
+    // A tool scoped to specific capabilities is hidden unless one matches. An
+    // unscoped resolution (no capability given) cannot satisfy the scope, so the
+    // tool stays hidden — scoping fails closed.
+    if (meta.targetCapabilities && meta.targetCapabilities.length > 0) {
+        if (!selection.capability || !meta.targetCapabilities.includes(selection.capability)) {
+            return false;
+        }
+    }
+    if (meta.invocationModes && meta.invocationModes.length > 0) {
+        if (!selection.mode || !meta.invocationModes.includes(selection.mode))
+            return false;
+    }
+    return true;
+}
+/**
+ * Narrow a tool surface to what a given capability and invocation mode may see.
+ * This is the projection that runs *before* the model ever hears about a tool.
+ */
+export function selectTools(tools, selection = {}) {
+    return tools.filter((tool) => isToolVisible(tool, selection));
+}
+/**
+ * Project tools down to the provider-facing definitions — name, description and
+ * input schema, and nothing else. Everything the metadata adds is intentionally
+ * dropped here: a model has no use for retention policy, and leaking it into
+ * the schema would only spend context.
+ */
+export function toToolSpecs(tools) {
+    return tools.map((tool) => tool.spec);
+}
+/** Tools that must not execute until a human has approved them. */
+export function toolsRequiringConfirmation(tools) {
+    return tools.filter((tool) => tool.meta?.requiresConfirmation === true);
+}
+/** Look up the tool that undoes `name`, when one is declared and reversible. */
+export function undoToolFor(tools, name) {
+    const tool = tools.find((t) => t.spec.name === name);
+    if (!tool?.meta?.reversible || !tool.meta.undoToolName)
+        return undefined;
+    return tools.find((t) => t.spec.name === tool.meta?.undoToolName);
+}
+//# sourceMappingURL=metadata.js.map

package/dist/tools/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../../src/tools/metadata.ts"],"names":[],"mappings":"AAiFA,qDAAqD;AACrD,MAAM,UAAU,aAAa,CAAC,IAAU,EAAE,YAA2B,EAAE;IACrE,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAA;IACtB,IAAI,SAAS,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAA;IAClF,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAA;IAEtB,0EAA0E;IAC1E,6EAA6E;IAC7E,4CAA4C;IAC5C,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClE,IAAI,CAAC,SAAS,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;YACrF,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IAED,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5D,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,CAAA;IACrF,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,KAAa,EAAE,YAA2B,EAAE;IACtE,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAA;AAC/D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,KAAa;IACvC,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACvC,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,0BAA0B,CAAC,KAAa;IACtD,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI,CAAC,CAAA;AACzE,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,WAAW,CAAC,KAAa,EAAE,IAAY;IACrD,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,CAAA;IACpD,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY;QAAE,OAAO,SAAS,CAAA;IACxE,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;AACnE,CAAC"}

package/dist/tools/modelTool.d.ts

@@ -0,0 +1,35 @@
+import type { InvokeContext, ModelInvocation, ModelResult } from "../models/types.js";
+import type { ToolMetadata } from "./metadata.js";
+import type { Tool } from "./registry.js";
+/** How to turn one model invocation into a callable tool. */
+export interface ModelToolOptions<Req, Res> {
+    /** Tool name the model calls. */
+    name: string;
+    description: string;
+    /** JSON-Schema shape advertised to the model. */
+    inputSchema: Record<string, unknown>;
+    /** Map the model's raw tool input to the invocation's request type. */
+    toRequest: (input: Record<string, unknown>) => Req;
+    /**
+     * Project the result down to the string the calling model sees. Defaults to
+     * JSON — fine for a struct, worth overriding when a short natural-language
+     * summary would spend less context than the full payload.
+     */
+    toContent?: (result: ModelResult<Res>) => string;
+    meta?: ToolMetadata;
+}
+/**
+ * Surface a {@link ModelInvocation} as a {@link Tool}.
+ *
+ * This is the cleanest form of "extension, not fork": a perception model — a
+ * `vision.detect` or an `audio.asr` — becomes something the chat loop can call,
+ * without the loop, the engines, or any kernel code learning that perception
+ * exists. The registry binds it, this wraps it, the agent calls it like any
+ * other tool.
+ *
+ * The typed result survives the trip: `content` is the model-facing projection,
+ * and `structured` carries the original `Res` for callers and clients that want
+ * the real thing rather than a re-parsed string.
+ */
+export declare function modelAsTool<Req, Res>(model: ModelInvocation<Req, Res>, options: ModelToolOptions<Req, Res>, context?: Partial<InvokeContext>): Tool;
+//# sourceMappingURL=modelTool.d.ts.map

package/dist/tools/modelTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelTool.d.ts","sourceRoot":"","sources":["../../src/tools/modelTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,KAAK,EAAE,IAAI,EAAc,MAAM,eAAe,CAAA;AAErD,6DAA6D;AAC7D,MAAM,WAAW,gBAAgB,CAAC,GAAG,EAAE,GAAG;IACxC,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,iDAAiD;IACjD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACpC,uEAAuE;IACvE,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,CAAA;IAClD;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,KAAK,MAAM,CAAA;IAChD,IAAI,CAAC,EAAE,YAAY,CAAA;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,EAClC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,EAChC,OAAO,EAAE,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,EACnC,OAAO,GAAE,OAAO,CAAC,aAAa,CAAM,GACnC,IAAI,CAwBN"}

package/dist/tools/modelTool.js

@@ -0,0 +1,37 @@
+/**
+ * Surface a {@link ModelInvocation} as a {@link Tool}.
+ *
+ * This is the cleanest form of "extension, not fork": a perception model — a
+ * `vision.detect` or an `audio.asr` — becomes something the chat loop can call,
+ * without the loop, the engines, or any kernel code learning that perception
+ * exists. The registry binds it, this wraps it, the agent calls it like any
+ * other tool.
+ *
+ * The typed result survives the trip: `content` is the model-facing projection,
+ * and `structured` carries the original `Res` for callers and clients that want
+ * the real thing rather than a re-parsed string.
+ */
+export function modelAsTool(model, options, context = {}) {
+    const project = options.toContent ?? ((result) => JSON.stringify(result.value));
+    const run = async (input) => {
+        const ctx = {
+            log: context.log ?? (() => { }),
+            ...(context.signal ? { signal: context.signal } : {}),
+            ...(context.correlationId ? { correlationId: context.correlationId } : {}),
+            ...(context.budget ? { budget: context.budget } : {}),
+        };
+        const result = await model.invoke(options.toRequest(input), ctx);
+        return { content: project(result), structured: result.value };
+    };
+    return {
+        spec: {
+            name: options.name,
+            description: options.description,
+            inputSchema: options.inputSchema,
+        },
+        ...(options.meta ? { meta: options.meta } : {}),
+        execute: async (input) => (await run(input)).content,
+        executeStructured: run,
+    };
+}
+//# sourceMappingURL=modelTool.js.map

package/dist/tools/modelTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelTool.js","sourceRoot":"","sources":["../../src/tools/modelTool.ts"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,WAAW,CACzB,KAAgC,EAChC,OAAmC,EACnC,UAAkC,EAAE;IAEpC,MAAM,OAAO,GAAG,OAAO,CAAC,SAAS,IAAI,CAAC,CAAC,MAAwB,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;IAEjG,MAAM,GAAG,GAAG,KAAK,EAAE,KAA8B,EAAuB,EAAE;QACxE,MAAM,GAAG,GAAkB;YACzB,GAAG,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;YAC9B,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACrD,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1E,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACtD,CAAA;QACD,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAA;QAChE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,KAAK,EAAE,CAAA;IAC/D,CAAC,CAAA;IAED,OAAO;QACL,IAAI,EAAE;YACJ,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,WAAW,EAAE,OAAO,CAAC,WAAW;SACjC;QACD,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/C,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO;QACpD,iBAAiB,EAAE,GAAG;KACvB,CAAA;AACH,CAAC"}

package/dist/tools/registry.d.ts

@@ -0,0 +1,65 @@
+import { type McpConnection } from "../connectors/mcpClient.js";
+import type { ConnectorConfig } from "../types.js";
+import type { ToolSpec } from "../providers/types.js";
+import type { ToolMetadata } from "./metadata.js";
+/**
+ * What a tool produced: the string the model sees, plus the typed payload that
+ * string was projected from.
+ *
+ * The model can only consume text, so `content` is what goes back into the
+ * conversation. But a caller that JSON-stringifies a struct on the way out and
+ * re-parses it on the way in has lost the type for no reason — so `structured`
+ * carries the original alongside, untouched.
+ */
+export interface ToolOutput {
+    /** The string projection fed back to the model. */
+    content: string;
+    /** The typed payload, preserved for callers and clients. */
+    structured?: unknown;
+}
+/** A tool the agent can call: its public spec plus a server-side executor. */
+export interface Tool {
+    spec: ToolSpec;
+    /** Optional descriptive metadata — scoping, confirmation, undo, retention. */
+    meta?: ToolMetadata;
+    /**
+     * Execute and return the model-facing string. This is the required contract
+     * every tool implements, and the only one the loop needs.
+     */
+    execute(input: Record<string, unknown>): Promise<string>;
+    /**
+     * Optional richer executor. When present the loop calls this instead and
+     * keeps the typed payload alongside the string; when absent nothing changes.
+     *
+     * Two methods rather than one widened return type is a deliberate
+     * concession to compatibility: every existing tool and every existing caller
+     * types `execute` as returning a plain `string`, and widening it to a union
+     * would break them at the type level for a payload most tools never produce.
+     */
+    executeStructured?(input: Record<string, unknown>): Promise<ToolOutput>;
+}
+/** Run a tool through its richest available executor. */
+export declare function executeTool(tool: Tool, input: Record<string, unknown>): Promise<ToolOutput>;
+/**
+ * General-purpose primitives, scoped to the run sandbox. `env` carries the
+ * resolved secrets (see secretsToEnv) into executed code. Domain logic is the
+ * user's own repo code, invoked through `run_code` — never baked in here.
+ *
+ * This set is strictly generic: sandboxed shell, file reads, and HTTP. Tools
+ * that collect an application's *domain output* are not here at all — they are
+ * the application's vocabulary, injected through the engines' domain-tool seam.
+ *
+ * When `allowed` is provided it acts as an allowlist of primitive tool names
+ * (from the workflow's `permissions.tools`).
+ */
+export declare function primitiveTools(sandboxDir: string, env: NodeJS.ProcessEnv, allowed?: string[], allowHosts?: string[]): Tool[];
+/**
+ * Tools exposed by the run's MCP connectors. Each connector's tools are
+ * namespaced `<connector>__<tool>` to avoid collisions. Returns a `close` to
+ * tear down the connections when the run ends.
+ */
+export declare function connectorTools(connectors: ConnectorConfig[], connect?: (config: ConnectorConfig) => Promise<McpConnection>): Promise<{
+    tools: Tool[];
+    close: () => Promise<void>;
+}>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/tools/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/tools/registry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAA;IACf,4DAA4D;IAC5D,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,8EAA8E;AAC9E,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAA;IACd,8EAA8E;IAC9E,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACxD;;;;;;;;OAQG;IACH,iBAAiB,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;CACxE;AAED,yDAAyD;AACzD,wBAAsB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAGjG;AAeD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,OAAO,CAAC,EAAE,MAAM,EAAE,EAClB,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,IAAI,EAAE,CA4FR;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,GAAE,CAAC,MAAM,EAAE,eAAe,KAAK,OAAO,CAAC,aAAa,CAAc,GACxE,OAAO,CAAC;IAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAuCxD"}

package/dist/tools/registry.js

@@ -0,0 +1,166 @@
+import { runCode } from "../primitives/codeExec.js";
+import { httpFetch } from "../primitives/http.js";
+import { readFileSafe, listFiles } from "../primitives/fs.js";
+import { connectMcp } from "../connectors/mcpClient.js";
+/** Run a tool through its richest available executor. */
+export async function executeTool(tool, input) {
+    if (tool.executeStructured)
+        return tool.executeStructured(input);
+    return { content: await tool.execute(input) };
+}
+const str = (v) => (typeof v === "string" ? v : "");
+const strArray = (v) => (Array.isArray(v) ? v.map(String) : []);
+/** Keep only string-valued headers (the model may pass arbitrary JSON). */
+function stringHeaders(v) {
+    if (!v || typeof v !== "object")
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(v)) {
+        if (typeof value === "string")
+            out[key] = value;
+    }
+    return out;
+}
+/**
+ * General-purpose primitives, scoped to the run sandbox. `env` carries the
+ * resolved secrets (see secretsToEnv) into executed code. Domain logic is the
+ * user's own repo code, invoked through `run_code` — never baked in here.
+ *
+ * This set is strictly generic: sandboxed shell, file reads, and HTTP. Tools
+ * that collect an application's *domain output* are not here at all — they are
+ * the application's vocabulary, injected through the engines' domain-tool seam.
+ *
+ * When `allowed` is provided it acts as an allowlist of primitive tool names
+ * (from the workflow's `permissions.tools`).
+ */
+export function primitiveTools(sandboxDir, env, allowed, allowHosts) {
+    const all = [
+        {
+            spec: {
+                name: "run_code",
+                description: "Run a shell command in the workspace sandbox — e.g. `node scan.mjs`, `npm ci`, or a one-liner. " +
+                    "`command` is a shell command line run via `/bin/sh -c`, so pipes, quoting and redirection work and " +
+                    "`node`/`npm`/etc. resolve on PATH. (Advanced: pass `args` to exec `command` as a bare binary with " +
+                    "those arguments, bypassing the shell.) Returns stdout, stderr, and the exit code.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        command: { type: "string" },
+                        args: { type: "array", items: { type: "string" } },
+                        stdin: { type: "string" },
+                    },
+                    required: ["command"],
+                },
+            },
+            execute: async (input) => {
+                const command = str(input.command);
+                const args = strArray(input.args);
+                const stdin = typeof input.stdin === "string" ? input.stdin : undefined;
+                // Default to running the command line through a shell (mirrors the verify
+                // gate's `/bin/sh -c`), so an agent can hand us `node scan.mjs` as a single
+                // string. When explicit args are given, exec the binary directly (no shell).
+                const result = args.length > 0
+                    ? await runCode({ cwd: sandboxDir, command, args, env, stdin })
+                    : await runCode({
+                        cwd: sandboxDir,
+                        command: "/bin/sh",
+                        args: ["-c", command],
+                        env,
+                        stdin,
+                    });
+                return JSON.stringify(result);
+            },
+        },
+        {
+            spec: {
+                name: "read_file",
+                description: "Read a UTF-8 file from the workspace sandbox.",
+                inputSchema: {
+                    type: "object",
+                    properties: { path: { type: "string" } },
+                    required: ["path"],
+                },
+            },
+            execute: async (input) => (await readFileSafe(sandboxDir, str(input.path))) ?? "(not found)",
+        },
+        {
+            spec: {
+                name: "list_files",
+                description: "List files under a directory in the workspace sandbox.",
+                inputSchema: {
+                    type: "object",
+                    properties: { dir: { type: "string" } },
+                },
+            },
+            execute: async (input) => (await listFiles(sandboxDir, str(input.dir) || ".")).join("\n"),
+        },
+        {
+            spec: {
+                name: "http_fetch",
+                description: "Make an HTTP request. Returns the status and response body.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        url: { type: "string" },
+                        method: { type: "string" },
+                        headers: { type: "object" },
+                        body: { type: "string" },
+                    },
+                    required: ["url"],
+                },
+            },
+            execute: async (input) => {
+                const res = await httpFetch({
+                    url: str(input.url),
+                    method: str(input.method) || "GET",
+                    headers: stringHeaders(input.headers),
+                    body: typeof input.body === "string" ? input.body : undefined,
+                    allowHosts, // egress allowlist from the workflow's permissions (undefined = any public host)
+                });
+                return JSON.stringify({ status: res.status, body: res.body });
+            },
+        },
+    ];
+    return allowed ? all.filter((t) => allowed.includes(t.spec.name)) : all;
+}
+/**
+ * Tools exposed by the run's MCP connectors. Each connector's tools are
+ * namespaced `<connector>__<tool>` to avoid collisions. Returns a `close` to
+ * tear down the connections when the run ends.
+ */
+export async function connectorTools(connectors, connect = connectMcp) {
+    const connections = [];
+    const tools = [];
+    const close = async () => {
+        await Promise.allSettled(connections.map((c) => c.close()));
+    };
+    try {
+        for (const config of connectors) {
+            if (config.kind !== "mcp")
+                continue;
+            const conn = await connect(config);
+            connections.push(conn);
+            const listed = (await conn.listTools());
+            for (const tool of listed.tools ?? []) {
+                tools.push({
+                    spec: {
+                        name: `${config.name}__${tool.name}`,
+                        description: tool.description ?? `${config.name} tool ${tool.name}`,
+                        inputSchema: tool.inputSchema ?? { type: "object" },
+                    },
+                    execute: async (input) => {
+                        const result = await conn.callTool(tool.name, input);
+                        return JSON.stringify(result);
+                    },
+                });
+            }
+        }
+    }
+    catch (err) {
+        // Don't leak connections opened before the failing one.
+        await close();
+        throw err;
+    }
+    return { tools, close };
+}
+//# sourceMappingURL=registry.js.map

package/dist/tools/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/tools/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACjD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,EAAE,UAAU,EAAsB,MAAM,4BAA4B,CAAA;AA2C3E,yDAAyD;AACzD,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,IAAU,EAAE,KAA8B;IAC1E,IAAI,IAAI,CAAC,iBAAiB;QAAE,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAA;IAChE,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAA;AAC/C,CAAC;AAED,MAAM,GAAG,GAAG,CAAC,CAAU,EAAU,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AACpE,MAAM,QAAQ,GAAG,CAAC,CAAU,EAAY,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAElF,2EAA2E;AAC3E,SAAS,aAAa,CAAC,CAAU;IAC/B,IAAI,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAA;IACjD,MAAM,GAAG,GAA2B,EAAE,CAAA;IACtC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,CAA4B,CAAC,EAAE,CAAC;QACxE,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;IACjD,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAC5B,UAAkB,EAClB,GAAsB,EACtB,OAAkB,EAClB,UAAqB;IAErB,MAAM,GAAG,GAAW;QAClB;YACE,IAAI,EAAE;gBACJ,IAAI,EAAE,UAAU;gBAChB,WAAW,EACT,iGAAiG;oBACjG,qGAAqG;oBACrG,oGAAoG;oBACpG,mFAAmF;gBACrF,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;wBAC3B,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;wBAClD,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;qBAC1B;oBACD,QAAQ,EAAE,CAAC,SAAS,CAAC;iBACtB;aACF;YACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;gBACvB,MAAM,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;gBAClC,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;gBACjC,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAA;gBACvE,0EAA0E;gBAC1E,4EAA4E;gBAC5E,6EAA6E;gBAC7E,MAAM,MAAM,GACV,IAAI,CAAC,MAAM,GAAG,CAAC;oBACb,CAAC,CAAC,MAAM,OAAO,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;oBAC/D,CAAC,CAAC,MAAM,OAAO,CAAC;wBACZ,GAAG,EAAE,UAAU;wBACf,OAAO,EAAE,SAAS;wBAClB,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC;wBACrB,GAAG;wBACH,KAAK;qBACN,CAAC,CAAA;gBACR,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;YAC/B,CAAC;SACF;QACD;YACE,IAAI,EAAE;gBACJ,IAAI,EAAE,WAAW;gBACjB,WAAW,EAAE,+CAA+C;gBAC5D,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;oBACxC,QAAQ,EAAE,CAAC,MAAM,CAAC;iBACnB;aACF;YACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM,YAAY,CAAC,UAAU,EAAE,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,aAAa;SAC7F;QACD;YACE,IAAI,EAAE;gBACJ,IAAI,EAAE,YAAY;gBAClB,WAAW,EAAE,wDAAwD;gBACrE,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;iBACxC;aACF;YACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;SAC1F;QACD;YACE,IAAI,EAAE;gBACJ,IAAI,EAAE,YAAY;gBAClB,WAAW,EAAE,6DAA6D;gBAC1E,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;wBACvB,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;wBAC1B,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;wBAC3B,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;qBACzB;oBACD,QAAQ,EAAE,CAAC,KAAK,CAAC;iBAClB;aACF;YACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;gBACvB,MAAM,GAAG,GAAG,MAAM,SAAS,CAAC;oBAC1B,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;oBACnB,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK;oBAClC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC;oBACrC,IAAI,EAAE,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;oBAC7D,UAAU,EAAE,iFAAiF;iBAC9F,CAAC,CAAA;gBACF,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,CAAA;YAC/D,CAAC;SACF;KACF,CAAA;IAED,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAA;AACzE,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,UAA6B,EAC7B,UAA+D,UAAU;IAEzE,MAAM,WAAW,GAAoB,EAAE,CAAA;IACvC,MAAM,KAAK,GAAW,EAAE,CAAA;IACxB,MAAM,KAAK,GAAG,KAAK,IAAmB,EAAE;QACtC,MAAM,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IAC7D,CAAC,CAAA;IAED,IAAI,CAAC;QACH,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE,CAAC;YAChC,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK;gBAAE,SAAQ;YAEnC,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;YAClC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAEtB,MAAM,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,CAErC,CAAA;YAED,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,IAAI,EAAE,EAAE,CAAC;gBACtC,KAAK,CAAC,IAAI,CAAC;oBACT,IAAI,EAAE;wBACJ,IAAI,EAAE,GAAG,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE;wBACpC,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,GAAG,MAAM,CAAC,IAAI,SAAS,IAAI,CAAC,IAAI,EAAE;wBACnE,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE;qBACpD;oBACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;wBACvB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;wBACpD,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;oBAC/B,CAAC;iBACF,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wDAAwD;QACxD,MAAM,KAAK,EAAE,CAAA;QACb,MAAM,GAAG,CAAA;IACX,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAA;AACzB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * A single external connector the harness can talk to. `kind` distinguishes a
+ * Model Context Protocol server from a plain HTTP service; `transport` selects
+ * the wire protocol for MCP connectors.
+ */
+export interface ConnectorConfig {
+    name: string;
+    kind: "mcp" | "http";
+    transport: "stdio" | "streamable_http" | "sse";
+    /** For streamable_http / sse transports. */
+    endpoint?: string;
+    /** For the stdio transport. */
+    command?: string;
+    args?: string[];
+    /** Token is already resolved by the caller; the kernel treats it as opaque. */
+    auth?: {
+        type: "bearer" | "none";
+        token?: string;
+    };
+}
+/**
+ * What a run is allowed to touch. `tools` acts as an allowlist of tool names,
+ * `hosts` as an egress allowlist for the http_fetch primitive; the open index
+ * signature lets callers carry their own policy keys through untouched.
+ */
+export interface Permissions {
+    read?: string[];
+    write?: string[];
+    tools?: string[];
+    /** Egress allowlist (host[:port]) for the http_fetch primitive. */
+    hosts?: string[];
+    [key: string]: unknown;
+}
+/**
+ * The declarative description of the work a run performs, as parsed from the
+ * caller's own workflow format. The kernel reads only what it needs (the
+ * prompt, permissions, provider preference); the remaining fields are carried
+ * through for engines and callers that care.
+ */
+export interface WorkflowDefinition {
+    name?: string;
+    trigger?: {
+        type?: string;
+    };
+    service?: {
+        exposed?: boolean;
+        name?: string;
+    };
+    permissions?: Permissions;
+    autonomy?: {
+        approval_required?: boolean;
+    };
+    context?: {
+        mode?: string;
+        files?: string[];
+    };
+    runner?: {
+        profile?: string;
+    };
+    provider?: {
+        preferred?: string;
+    };
+    prompt?: string;
+    /** Shell commands run in the sandbox BEFORE the agent, to install the run's own
+     *  dependencies (e.g. `npm ci`). Runs with the run's secrets in env; a failure
+     *  aborts the run (the agent must not run without its deps). */
+    setup?: string[];
+    /** Shell commands run as a deterministic audit gate after output is produced. */
+    verify?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AASA;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,KAAK,GAAG,MAAM,CAAA;IACpB,SAAS,EAAE,OAAO,GAAG,iBAAiB,GAAG,KAAK,CAAA;IAC9C,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,+EAA+E;IAC/E,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CACnD;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC3B,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9C,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,QAAQ,CAAC,EAAE;QAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;IAC1C,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;IAC7C,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7B,QAAQ,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;oEAEgE;IAChE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,iFAAiF;IACjF,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAClB"}

package/dist/types.js

@@ -0,0 +1,10 @@
+// The shapes a caller hands the kernel: what a run is *given* — connectors,
+// permissions, a workflow. Nothing here is application-specific.
+//
+// What a run *emits* used to live here too, as `KnowledgeEntry` and
+// `IssueEntry`. It doesn't any more: those were one product's vocabulary, and a
+// kernel that names them has already lost the argument. Emissions are opaque —
+// see `EngineResult.emissions`. A host defines its own emission shapes and
+// casts.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,iEAAiE;AACjE,EAAE;AACF,oEAAoE;AACpE,gFAAgF;AAChF,+EAA+E;AAC/E,2EAA2E;AAC3E,SAAS"}