@guuey/host 0.1.0

package/dist/run-openai.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The OpenAI (`@openai/agents`) arm of the universal host loop. Mirrors
+ * `run.ts`'s `runInvoke` shape: one invoke → an `@openai/agents` `Agent` built
+ * from the snapshot, run streamed, each raw `RunStreamEvent` emitted to fd-3 as
+ * a `native('openai-agents-sdk', …)` WorkerEvent (the Router dispatches them to
+ * the `@silverprotocol/openai-agents` normalizer). On clean completion it emits
+ * `done`; on `MaxTurnsExceededError` it emits the `__host_error__` sentinel the
+ * normalizer maps to `turn.error` (code `max_turns`), THEN `done(..,"max_turns")`;
+ * on any other failure it emits `error`. Never throws — every failure path is a
+ * terminal event so the Router always sees one. Emits `hello` FIRST (§8 item B)
+ * — the SDK-version handshake.
+ *
+ * `run` (the `@openai/agents` runner) is injected so the loop is unit-testable
+ * without a live model — the entrypoint (`index.ts`) passes the real SDK `run`.
+ *
+ * Snapshot → Agent mapping:
+ *  - `model`        → `snapshot.model` (or the SDK's own default when absent —
+ *                     NOT Claude's; this is the OpenAI path).
+ *  - `instructions` → `systemPrompt` + the §1.4 context preamble (reuses
+ *                     `withContextPreamble`, identical to the Claude path).
+ *  - `mcpServers`   → the framework-neutral `resolveMcpServers` output (same
+ *                     federation/env-substitution as Claude), each `http`/`sse`
+ *                     entry → an `MCPServerStreamableHttp` carrying its
+ *                     `Authorization` (and any other) header via `requestInit`.
+ *  - `maxTurns`     → `snapshot.runtime?.maxTurns` (passed to `run(...)`; the SDK
+ *                     THROWS `MaxTurnsExceededError` from `stream.completed`).
+ *  - API key        → `OPENAI_API_KEY` (the Router sets it at pod boot), applied
+ *                     globally via `setDefaultOpenAIKey` by the entrypoint.
+ */
+import { Agent, type RunStreamEvent } from "@openai/agents";
+import type { Emitter } from "@guuey/worker";
+import type { HostInvoke, HostRuntime } from "./run.js";
+import { type GuueyAgent } from "@guuey/config";
+/**
+ * The streamed-result surface the loop CONSUMES — exactly the three members it
+ * reads off the `@openai/agents` `StreamedRunResult`: async iteration over raw
+ * events, `completed` (which THROWS `MaxTurnsExceededError`), and the resolved
+ * `finalOutput`. A minimal structural interface (NOT the full `StreamedRunResult`
+ * class) so the real runner result AND a test fake both satisfy it without a cast
+ * — `StreamedRunResult` has private fields, so a plain object could never match
+ * the class, but it DOES match this read-only projection.
+ */
+export interface OpenaiRunResult extends AsyncIterable<RunStreamEvent> {
+    readonly completed: Promise<void>;
+    /** Resolved text output for the default text-output Agent (or `undefined`). */
+    readonly finalOutput?: string | undefined;
+}
+/**
+ * The `run` surface the loop needs — the real `@openai/agents` `run` (streamed
+ * overload) satisfies it (its `StreamedRunResult` is assignable to
+ * {@link OpenaiRunResult}). Injected so the loop is testable without a live model.
+ */
+export type OpenaiRunFn = (agent: Agent, input: string, options: {
+    stream: true;
+    maxTurns?: number;
+}) => Promise<OpenaiRunResult>;
+/**
+ * Run one invoke through `@openai/agents`. Emits `native` per `RunStreamEvent`,
+ * `done` on completion (with the `max_turns` sentinel + reason on a turn-cap),
+ * `error` on a build failure or any non-max-turns throw. Never throws.
+ */
+export declare function runInvokeOpenai(snapshot: GuueyAgent & {
+    framework?: string;
+}, invoke: HostInvoke, runtime: HostRuntime, emit: Emitter, run: OpenaiRunFn): Promise<void>;
+//# sourceMappingURL=run-openai.d.ts.map

package/dist/run-openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-openai.d.ts","sourceRoot":"","sources":["../src/run-openai.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EACL,KAAK,EAIL,KAAK,cAAc,EACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,eAAe,CAAC;AAOxD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,EAA+B,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAQ7E;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAgB,SAAQ,aAAa,CAAC,cAAc,CAAC;IACpE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,+EAA+E;IAC/E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3C;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,KACzC,OAAO,CAAC,eAAe,CAAC,CAAC;AAgB9B;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,UAAU,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EAC7C,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,IAAI,CAAC,CA4Gf"}

package/dist/run-openai.js

@@ -0,0 +1,207 @@
+/**
+ * The OpenAI (`@openai/agents`) arm of the universal host loop. Mirrors
+ * `run.ts`'s `runInvoke` shape: one invoke → an `@openai/agents` `Agent` built
+ * from the snapshot, run streamed, each raw `RunStreamEvent` emitted to fd-3 as
+ * a `native('openai-agents-sdk', …)` WorkerEvent (the Router dispatches them to
+ * the `@silverprotocol/openai-agents` normalizer). On clean completion it emits
+ * `done`; on `MaxTurnsExceededError` it emits the `__host_error__` sentinel the
+ * normalizer maps to `turn.error` (code `max_turns`), THEN `done(..,"max_turns")`;
+ * on any other failure it emits `error`. Never throws — every failure path is a
+ * terminal event so the Router always sees one. Emits `hello` FIRST (§8 item B)
+ * — the SDK-version handshake.
+ *
+ * `run` (the `@openai/agents` runner) is injected so the loop is unit-testable
+ * without a live model — the entrypoint (`index.ts`) passes the real SDK `run`.
+ *
+ * Snapshot → Agent mapping:
+ *  - `model`        → `snapshot.model` (or the SDK's own default when absent —
+ *                     NOT Claude's; this is the OpenAI path).
+ *  - `instructions` → `systemPrompt` + the §1.4 context preamble (reuses
+ *                     `withContextPreamble`, identical to the Claude path).
+ *  - `mcpServers`   → the framework-neutral `resolveMcpServers` output (same
+ *                     federation/env-substitution as Claude), each `http`/`sse`
+ *                     entry → an `MCPServerStreamableHttp` carrying its
+ *                     `Authorization` (and any other) header via `requestInit`.
+ *  - `maxTurns`     → `snapshot.runtime?.maxTurns` (passed to `run(...)`; the SDK
+ *                     THROWS `MaxTurnsExceededError` from `stream.completed`).
+ *  - API key        → `OPENAI_API_KEY` (the Router sets it at pod boot), applied
+ *                     globally via `setDefaultOpenAIKey` by the entrypoint.
+ */
+import { Agent, MaxTurnsExceededError, MCPServerStreamableHttp, } from "@openai/agents";
+import { resolveMcpServers, withContextPreamble, } from "./options.js";
+import { GUUEY_DEFAULT_SYSTEM_PROMPT } from "@guuey/config";
+import { resolveSdkVersion } from "./sdk-version.js";
+/** The framework tag this arm runs — matches the `AgentFramework` enum value. */
+const OPENAI_FRAMEWORK = "openai-agents-sdk";
+/** The npm package whose installed version is this framework's `hello.sdkVersion`. */
+const OPENAI_SDK_PACKAGE = "@openai/agents";
+/**
+ * Run one invoke through `@openai/agents`. Emits `native` per `RunStreamEvent`,
+ * `done` on completion (with the `max_turns` sentinel + reason on a turn-cap),
+ * `error` on a build failure or any non-max-turns throw. Never throws.
+ */
+export async function runInvokeOpenai(snapshot, invoke, runtime, emit, run) {
+    // The SDK-version handshake (§8 item B, additive-optional) — ALWAYS the
+    // first event of this invoke's fd-3 stream, before any native/turn event.
+    // `sdkVersion` is resolved at runtime, never hardcoded; `null` (SDK not
+    // resolvable) is tolerated by the Router.
+    emit.hello(OPENAI_FRAMEWORK, OPENAI_SDK_PACKAGE, resolveSdkVersion(OPENAI_SDK_PACKAGE));
+    // The host runs inside the Router's bubblewrap jail with NO IRSA; a federated
+    // MCP server reads its Router-written credential file. `resolveMcpServers`
+    // needs the same per-invoke context the Claude path builds.
+    const ctx = {
+        input: invoke.input,
+        identity: invoke.identity,
+        fs: invoke.fs,
+        history: invoke.history,
+        listCredentials: runtime.listCredentials,
+        ...(runtime.apiKey !== undefined ? { apiKey: runtime.apiKey } : {}),
+        ...(invoke.priorMemory !== undefined ? { priorMemory: invoke.priorMemory } : {}),
+        ...(invoke.priorState !== undefined ? { priorState: invoke.priorState } : {}),
+    };
+    // Build the Agent (+ connect its MCP servers). A build failure (e.g. an
+    // unresolved {file} system prompt, or an unsupported MCP arm) is a terminal
+    // `error` — never a throw out of this function.
+    let instructions;
+    let mcpServers;
+    try {
+        // Snapshots reach the worker fully resolved — the CLI inlines any `{file}`
+        // system prompt before upload. A non-string reaching the worker means a
+        // direct API hit with an un-resolved snapshot; reject loudly (same as Claude).
+        if (snapshot.systemPrompt !== undefined && typeof snapshot.systemPrompt !== "string") {
+            throw new Error(`@guuey/host: snapshot.systemPrompt must be a resolved string (got ${JSON.stringify(snapshot.systemPrompt)}). The CLI inlines {file} references before upload; workers never read the filesystem.`);
+        }
+        instructions = withContextPreamble(snapshot.systemPrompt ?? GUUEY_DEFAULT_SYSTEM_PROMPT, ctx.history, ctx.priorMemory, ctx.priorState);
+        mcpServers = buildOpenaiMcpServers(ctx);
+    }
+    catch (err) {
+        emit.error(err instanceof Error ? err.message : String(err));
+        return;
+    }
+    try {
+        for (const server of mcpServers) {
+            await server.connect();
+        }
+    }
+    catch (err) {
+        await closeAll(mcpServers);
+        emit.error(err instanceof Error ? err.message : String(err));
+        return;
+    }
+    try {
+        const maxTurns = snapshot.runtime?.maxTurns;
+        // `MCPServerStreamableHttp` IS an `MCPServer`; the Agent's `mcpServers` field
+        // is `MCPServer[]` — widen via the interface (no cast; structural subtype).
+        const servers = mcpServers;
+        const agent = new Agent({
+            name: "guuey-agent",
+            instructions,
+            mcpServers: servers,
+            ...(snapshot.model !== undefined ? { model: snapshot.model } : {}),
+        });
+        const stream = await run(agent, invoke.input, {
+            stream: true,
+            ...(maxTurns !== undefined ? { maxTurns } : {}),
+        });
+        // Drive the stream: each raw event crosses the wire as native.
+        for await (const ev of stream) {
+            emit.native(OPENAI_FRAMEWORK, toJson(ev));
+        }
+        // The runner THROWS `MaxTurnsExceededError` from `completed` AFTER the stream
+        // ends. Catch it specifically → feed the normalizer the `__host_error__`
+        // sentinel, then a terminal `done(.., "max_turns")`. Other throws → `error`.
+        try {
+            await stream.completed;
+        }
+        catch (err) {
+            if (err instanceof MaxTurnsExceededError) {
+                // The `__host_error__` sentinel — a fresh object literal so it is checked
+                // directly against `JsonValue` (the `native` payload type). Shape is the
+                // BINDING contract {@link HostErrorSentinel}.
+                emit.native(OPENAI_FRAMEWORK, {
+                    type: "__host_error__",
+                    code: "max_turns",
+                    message: err.message,
+                });
+                emit.done(finalText(stream), "max_turns");
+                return;
+            }
+            throw err;
+        }
+        emit.done(finalText(stream), "end_turn");
+    }
+    catch (err) {
+        emit.error(err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        await closeAll(mcpServers);
+    }
+}
+/**
+ * The agent's final text output, or `""` when absent (a tool-only turn, or a
+ * turn cut short by `max_turns`). For the default text-output Agent `finalOutput`
+ * is `string | undefined`.
+ */
+function finalText(stream) {
+    const out = stream.finalOutput;
+    return typeof out === "string" ? out : "";
+}
+/**
+ * Translate the framework-neutral resolved MCP map → connected-capable
+ * `MCPServerStreamableHttp` instances. Each `http`/`sse` entry's `headers`
+ * (typically `{ authorization: 'Bearer <token>' }`, from the federation
+ * credential file or `${env.NAME}` substitution) ride on the underlying MCP
+ * transport's `RequestInit.headers` via `requestInit`.
+ *
+ * The cred dir only yields `http`/`sse` servers (the Router resolves all
+ * transport to one of those two); the `stdio` arm below is unreachable
+ * defensive code — kept so a future schema change can't silently drop a server.
+ */
+function buildOpenaiMcpServers(ctx) {
+    const resolved = resolveMcpServers(ctx);
+    const servers = [];
+    for (const [name, entry] of Object.entries(resolved)) {
+        servers.push(toOpenaiMcpServer(name, entry));
+    }
+    return servers;
+}
+/**
+ * One resolved `SdkMcpServer` → an `MCPServerStreamableHttp`. Both `http` and
+ * `sse` arms map to the StreamableHTTP server (the SDK's HTTP MCP transport);
+ * the `stdio` arm is unreachable (`resolveMcpServers` rejects colocated before
+ * we get here) — handled with a loud throw so a future schema change can't
+ * silently drop a server.
+ */
+function toOpenaiMcpServer(name, entry) {
+    if (entry.type === "stdio") {
+        throw new Error(`mcpServers["${name}"]: stdio (colocated) MCP is not supported on the OpenAI host path.`);
+    }
+    const headers = entry.headers;
+    return new MCPServerStreamableHttp({
+        url: entry.url,
+        name,
+        ...(headers && Object.keys(headers).length > 0 ? { requestInit: { headers } } : {}),
+        // `customDataExtractor` (agents 0.12+) is the ONLY channel that carries an
+        // MCP tool result's `structuredContent` onto the wire (`item.customData`)
+        // WITHOUT leaking it into model-visible text — without this, the ggui cache
+        // marker never reaches the normalizer and render metering goes blind.
+        // Mirrors the verified silverprotocol capture-agent wiring; the facet reads
+        // `item.customData.structuredContent`.
+        customDataExtractor: (context) => context.structuredContent !== undefined
+            ? { structuredContent: context.structuredContent }
+            : undefined,
+    });
+}
+/** Best-effort close of every connected MCP server (release the transport). */
+async function closeAll(servers) {
+    await Promise.allSettled(servers.map((s) => s.close()));
+}
+/**
+ * Coerce one `RunStreamEvent` to the `JsonValue` the `native` event carries.
+ * Stream events are plain JSON-serializable objects; the round-trip drops any
+ * non-JSON surface and yields the exact shape the Router's normalizer parses off
+ * the wire. Mirrors `run.ts`'s `toJson`.
+ */
+function toJson(ev) {
+    return JSON.parse(JSON.stringify(ev));
+}

package/dist/run.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The testable core of the worker loop. `runInvoke` runs one invoke through the
+ * Claude Agent SDK and emits each native `SDKMessage` to fd-3 as a `native`
+ * WorkerEvent (the Router dispatches them to the matching normalizer). On the
+ * SDK result message it emits `done`; on a throw or a framework-gate violation
+ * it emits `error`. Emits `hello` FIRST (§8 item B) — the SDK-version handshake.
+ *
+ * `query` is injected so the loop is unit-testable without a live model. The
+ * worker entrypoint (`index.ts`) passes the real `@anthropic-ai/claude-agent-sdk`
+ * `query`.
+ */
+import type { Options, SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { Emitter, Fs, HistoryMessage, Identity, JsonValue } from "@guuey/worker";
+import { buildOptions, type CredentialFile, type PriorMemoryRecord } from "./options.js";
+/**
+ * The invoke this host consumes. A superset of `@guuey/worker`'s `Invoke`:
+ * `priorMemory`/`priorState` are the §1.4 push-by-value context the worker reads
+ * for the preamble (the Worker Protocol `Invoke` is EXTENDED with these in
+ * Task 3; until then the worker loop parses them off the raw control line).
+ */
+export interface HostInvoke {
+    input: string;
+    identity: Identity;
+    fs: Fs;
+    history: HistoryMessage[];
+    priorMemory?: PriorMemoryRecord[];
+    priorState?: JsonValue;
+}
+/** Per-process config the worker resolves once at boot. */
+export interface HostRuntime {
+    /**
+     * Anthropic API key — local-dev fallback when `baseUrl`+`authToken` are
+     * absent. One of (`baseUrl`+`authToken`) or `apiKey` must be provided;
+     * `buildOptions` throws at invoke time if neither is present.
+     */
+    apiKey?: string;
+    /**
+     * Loopback proxy base URL (hosted/broker mode). Task 8 injects this as
+     * `ANTHROPIC_BASE_URL` via `buildWorkerEnv`. When set together with
+     * `authToken`, the Claude CLI subprocess routes through the managed-LLM
+     * broker; the real API key is intentionally absent to prevent leaks.
+     */
+    baseUrl?: string;
+    /**
+     * Opaque session token for the loopback proxy (hosted/broker mode). Task 8
+     * injects this as `ANTHROPIC_AUTH_TOKEN`. Required when `baseUrl` is set.
+     */
+    authToken?: string;
+    /**
+     * Returns every credential the Router broker wrote to
+     * `<sessionDir>/.guuey/credentials/` this invoke. Injected so the run path
+     * stays pure (no disk access inside `runInvoke`).
+     */
+    listCredentials: () => Array<{
+        name: string;
+        cred: CredentialFile;
+    }>;
+}
+/** The `query` surface the loop needs — the real SDK `query` satisfies it. */
+export type QueryFn = (params: {
+    prompt: string;
+    options: Options;
+}) => AsyncIterable<SDKMessage>;
+/**
+ * Run one invoke. Emits `native` per SDKMessage, `done` on the result, `error`
+ * on a framework-gate violation or a thrown error. Never throws — every failure
+ * path becomes an `error` event so the Router always sees a terminal event.
+ */
+export declare function runInvoke(snapshot: {
+    framework?: string;
+} & Parameters<typeof buildOptions>[0], invoke: HostInvoke, runtime: HostRuntime, emit: Emitter, query: QueryFn): Promise<void>;
+//# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAc,MAAM,eAAe,CAAC;AAClG,OAAO,EACL,YAAY,EAEZ,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACvB,MAAM,cAAc,CAAC;AAQtB;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,EAAE,EAAE,EAAE,CAAC;IACP,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,WAAW,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,SAAS,CAAC;CACxB;AAED,2DAA2D;AAC3D,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,eAAe,EAAE,MAAM,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,cAAc,CAAA;KAAE,CAAC,CAAC;CACtE;AAED,8EAA8E;AAC9E,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB,KAAK,aAAa,CAAC,UAAU,CAAC,CAAC;AA0BhC;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,EACrE,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,IAAI,CAAC,CAgDf"}

package/dist/run.js

@@ -0,0 +1,80 @@
+import { buildOptions, } from "./options.js";
+import { resolveSdkVersion } from "./sdk-version.js";
+/** The framework THIS run path runs. OpenAI has its own path (`run-openai.ts`). */
+const CLAUDE_FRAMEWORK = "claude-agent-sdk";
+/** The npm package whose installed version is this framework's `hello.sdkVersion`. */
+const CLAUDE_SDK_PACKAGE = "@anthropic-ai/claude-agent-sdk";
+function isResultMessage(msg) {
+    return msg.type === "result";
+}
+/** Map the SDK result message → the Worker Protocol `done` stopReason + result. */
+function resultToDone(msg) {
+    const result = typeof msg.result === "string" ? msg.result : "";
+    const stopReason = msg.subtype === "success"
+        ? "end_turn"
+        : msg.subtype === "error_max_turns"
+            ? "max_turns"
+            : "error";
+    return { stopReason, result };
+}
+/**
+ * Run one invoke. Emits `native` per SDKMessage, `done` on the result, `error`
+ * on a framework-gate violation or a thrown error. Never throws — every failure
+ * path becomes an `error` event so the Router always sees a terminal event.
+ */
+export async function runInvoke(snapshot, invoke, runtime, emit, query) {
+    // The SDK-version handshake (§8 item B, additive-optional) — ALWAYS the
+    // first event of this invoke's fd-3 stream, before the framework gate or any
+    // native/turn event. `sdkVersion` is resolved at runtime, never hardcoded;
+    // `null` (SDK not resolvable) is tolerated by the Router.
+    emit.hello(CLAUDE_FRAMEWORK, CLAUDE_SDK_PACKAGE, resolveSdkVersion(CLAUDE_SDK_PACKAGE));
+    // Framework gate: this run path is the Claude SDK. OpenAI agents route to
+    // `runInvokeOpenai` (selected in `index.ts` by `snapshot.framework`) and never
+    // reach here. A non-claude framework arriving here (e.g. `google-adk`,
+    // `vanilla`) has no run path yet → a clear `error`, never a silent mis-run.
+    if (snapshot.framework && snapshot.framework !== CLAUDE_FRAMEWORK) {
+        emit.error(`@guuey/host: the claude run path got framework '${snapshot.framework}'; no run path for it yet.`);
+        return;
+    }
+    let options;
+    try {
+        const ctx = {
+            input: invoke.input,
+            identity: invoke.identity,
+            fs: invoke.fs,
+            history: invoke.history,
+            listCredentials: runtime.listCredentials,
+            ...(runtime.apiKey !== undefined ? { apiKey: runtime.apiKey } : {}),
+            ...(runtime.baseUrl !== undefined ? { baseUrl: runtime.baseUrl } : {}),
+            ...(runtime.authToken !== undefined ? { authToken: runtime.authToken } : {}),
+            ...(invoke.priorMemory !== undefined ? { priorMemory: invoke.priorMemory } : {}),
+            ...(invoke.priorState !== undefined ? { priorState: invoke.priorState } : {}),
+        };
+        options = buildOptions(snapshot, ctx);
+    }
+    catch (err) {
+        emit.error(err instanceof Error ? err.message : String(err));
+        return;
+    }
+    try {
+        let done;
+        for await (const msg of query({ prompt: invoke.input, options })) {
+            emit.native(CLAUDE_FRAMEWORK, toJson(msg));
+            if (isResultMessage(msg))
+                done = resultToDone(msg);
+        }
+        emit.done(done?.result ?? "", done?.stopReason ?? "end_turn");
+    }
+    catch (err) {
+        emit.error(err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * Coerce one SDKMessage to the `JsonValue` the `native` event carries. SDK
+ * messages are plain JSON-serializable objects; the round-trip drops any
+ * non-JSON surface (functions/symbols never appear on them) and yields the
+ * exact shape the Router's normalizer parses off the wire.
+ */
+function toJson(msg) {
+    return JSON.parse(JSON.stringify(msg));
+}

package/dist/sdk-version.d.ts

@@ -0,0 +1,5 @@
+/** Reads the installed `pkgName` package's own `package.json#version`, or
+ *  `null` when the package isn't installed / its version can't be resolved
+ *  (never throws — a missing SDK is tolerated, not fatal). */
+export declare function resolveSdkVersion(pkgName: string, anchorPath?: string): string | null;
+//# sourceMappingURL=sdk-version.d.ts.map

package/dist/sdk-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-version.d.ts","sourceRoot":"","sources":["../src/sdk-version.ts"],"names":[],"mappings":"AA0BA;;8DAE8D;AAC9D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA6BrF"}

package/dist/sdk-version.js

@@ -0,0 +1,56 @@
+/**
+ * Resolves an installed SDK package's own `package.json#version` at RUNTIME —
+ * the real resolved version (never a hardcoded literal, and never the
+ * `package.json` dependency RANGE, which may be a caret). Feeds the worker
+ * hello handshake's `sdkVersion` field (§8 item B).
+ *
+ * Mirrors silverprotocol's `resolveSdkVersion`
+ * (`sdks/typescript/packages/e2e/src/capture-cli.ts`): `require.resolve(pkg)`
+ * finds the package's main entry — `require.resolve(`${pkg}/package.json`)`
+ * (the naive approach) THROWS `ERR_PACKAGE_PATH_NOT_EXPORTED` for a package
+ * whose `exports` map omits a `./package.json` subpath, which is the case for
+ * BOTH `@anthropic-ai/claude-agent-sdk` and `@openai/agents` (verified
+ * empirically in that playbook run) — so we walk up from the main entry's
+ * directory instead, bounded to a few levels (real packages are 0-2 levels
+ * deep), until we find the `package.json` whose own `name` matches.
+ */
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const require = createRequire(import.meta.url);
+/** Real packages are 0-2 levels deep from their resolved main entry. */
+const MAX_WALK_UP_DEPTH = 5;
+/** Reads the installed `pkgName` package's own `package.json#version`, or
+ *  `null` when the package isn't installed / its version can't be resolved
+ *  (never throws — a missing SDK is tolerated, not fatal). */
+export function resolveSdkVersion(pkgName, anchorPath) {
+    try {
+        // `anchorPath` re-anchors resolution to another tree (the graceful agent
+        // entry's node_modules) — the single-copy rule needs the version of the
+        // copy actually driven, not the host's.
+        const resolver = anchorPath !== undefined ? createRequire(pathToFileURL(anchorPath).href) : require;
+        const mainEntryPath = resolver.resolve(pkgName);
+        let dir = dirname(mainEntryPath);
+        for (let depth = 0; depth < MAX_WALK_UP_DEPTH; depth++) {
+            const candidate = join(dir, "package.json");
+            try {
+                const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+                if (parsed.name === pkgName) {
+                    return parsed.version ?? null;
+                }
+            }
+            catch {
+                // Not found at this level (or unparsable) — keep walking up.
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                break; // reached filesystem root
+            dir = parent;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@guuey/host",
+  "version": "0.1.0",
+  "description": "The universal config-driven Guuey worker. Reads the resolved agent.json snapshot, runs the Claude Agent SDK, and emits each native SDKMessage to fd-3 as a `native` WorkerEvent.",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "guuey-host": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@guuey/config": "0.1.1",
+    "@guuey/worker": "0.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.199",
+    "@openai/agents": "^0.12.0",
+    "@google/adk": "^1.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "guuey",
+    "agent",
+    "worker",
+    "host",
+    "claude-agent-sdk"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/withguuey/guuey-sdks.git",
+    "directory": "packages/host"
+  },
+  "homepage": "https://guuey.com",
+  "bugs": {
+    "url": "https://github.com/loqu-co/guuey/issues"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.199",
+    "@google/adk": ">=1.0.0 <2",
+    "@openai/agents": "^0.12.0"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    },
+    "@google/adk": {
+      "optional": true
+    },
+    "@openai/agents": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}