@glubean/port 0.1.0

package/dist/lifecycle.js

@@ -0,0 +1,517 @@
+import { AsyncQueue } from "./async-queue.js";
+import { resolveRuntimeOptions } from "./options.js";
+import { startStructuredTurn } from "./structured.js";
+const DEFAULT_ACCEPT_TIMEOUT_MS = 30_000;
+export function createLifecyclePort(adapter) {
+    return new LifecycleRuntime(adapter).port;
+}
+class LifecycleRuntime {
+    #adapter;
+    #sessions = new Map();
+    #turns = new Map();
+    #eventLog = [];
+    #subscribers = new Set();
+    #seq = 0;
+    constructor(adapter) {
+        this.#adapter = adapter;
+    }
+    get port() {
+        return {
+            provider: this.#adapter.id,
+            capabilities: this.#adapter.capabilities,
+            sessions: {
+                create: (input = {}) => this.#createSession(input),
+                resume: (input) => this.#resumeSession(input),
+                attach: (input) => this.#resumeSession(input),
+                status: (input) => this.#sessionStatus(input),
+                list: (input = {}) => this.#sessionList(input),
+                close: (input) => this.#closeSession(input),
+            },
+            turns: {
+                start: (input) => this.#startTurn(input),
+                submit: (input) => this.#submitTurn(input),
+                status: (input) => this.#turnStatus(input),
+                stream: (input) => this.#events(input),
+                wait: (input) => this.#waitTurn(input),
+                startStructured: (input) => startStructuredTurn(this.#managedAdapter(), input),
+                cancel: (input) => this.#cancelTurn(input),
+            },
+            events: (input = {}) => this.#events(input),
+            close: () => this.#close(),
+        };
+    }
+    #managedAdapter() {
+        return {
+            ...this.#adapter,
+            startTurn: (input) => this.#startTurn(input),
+            cancelTurn: (input) => this.#cancelTurn(input),
+            events: () => this.#events(),
+        };
+    }
+    async #createSession(input) {
+        const session = await this.#adapter.createSession(input);
+        this.#upsertSession(session, "idle");
+        this.#record({
+            type: "session.started",
+            sessionId: session.id,
+            provider: session.provider,
+            ...(session.native ? { native: session.native } : {}),
+        });
+        return session;
+    }
+    async #resumeSession(input) {
+        const session = await this.#adapter.resumeSession(input);
+        this.#upsertSession(session, "idle");
+        return session;
+    }
+    async #sessionStatus(input) {
+        const session = this.#sessions.get(input.id);
+        if (!session) {
+            return {
+                id: input.id,
+                provider: this.#adapter.id,
+                status: "unknown",
+                activeTurnIds: [],
+            };
+        }
+        return snapshotSession(session);
+    }
+    async #sessionList(input) {
+        const snapshots = [...this.#sessions.values()].map(snapshotSession);
+        return input.status ? snapshots.filter((session) => session.status === input.status) : snapshots;
+    }
+    async #closeSession(input) {
+        const session = this.#sessions.get(input.id);
+        if (!session)
+            return;
+        if (input.cancelActiveTurns !== false) {
+            const activeTurnIds = [...session.activeTurnIds];
+            await Promise.all(activeTurnIds.map((turnId) => this.#cancelTurn({ sessionId: input.id, turnId }).catch(() => undefined)));
+        }
+        session.status = "closed";
+        session.activeTurnIds.clear();
+        session.updatedAt = nowIso();
+    }
+    #startTurn(input) {
+        const runtime = this;
+        return {
+            async *[Symbol.asyncIterator]() {
+                let currentTurnId;
+                let terminalSeen = false;
+                try {
+                    for await (const raw of runtime.#adapter.startTurn(input)) {
+                        const event = runtime.#withContext(raw, input.sessionId, currentTurnId);
+                        const ref = eventToRef(runtime.#adapter.id, event, input.sessionId);
+                        if (ref && !currentTurnId)
+                            currentTurnId = ref.turnId;
+                        if (event.type === "turn.completed")
+                            terminalSeen = true;
+                        runtime.#record(event, input);
+                        yield event;
+                    }
+                    if (currentTurnId && !terminalSeen) {
+                        const completed = completedEvent(input.sessionId, currentTurnId, "completed");
+                        runtime.#record(completed, input);
+                        yield completed;
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (currentTurnId) {
+                        const errorEvent = { type: "error", sessionId: input.sessionId, turnId: currentTurnId, message };
+                        const completed = completedEvent(input.sessionId, currentTurnId, "failed", message);
+                        runtime.#record(errorEvent, input);
+                        runtime.#record(completed, input);
+                        yield errorEvent;
+                        yield completed;
+                    }
+                    throw error;
+                }
+            },
+        };
+    }
+    async #submitTurn(input) {
+        let accepted = false;
+        let acceptTimer;
+        const acceptedPromise = new Promise((resolve, reject) => {
+            acceptTimer = setTimeout(() => {
+                if (!accepted)
+                    reject(new Error(`turn was not accepted within ${input.acceptTimeoutMs ?? DEFAULT_ACCEPT_TIMEOUT_MS}ms`));
+            }, input.acceptTimeoutMs ?? DEFAULT_ACCEPT_TIMEOUT_MS);
+            this.#consumeSubmittedTurn(input, (ref) => {
+                accepted = true;
+                if (acceptTimer)
+                    clearTimeout(acceptTimer);
+                resolve(ref);
+            }, (error) => {
+                if (acceptTimer)
+                    clearTimeout(acceptTimer);
+                reject(error);
+            });
+        });
+        return acceptedPromise;
+    }
+    #consumeSubmittedTurn(input, onAccepted, onRejected) {
+        void (async () => {
+            let currentTurnId;
+            let accepted = false;
+            let terminalSeen = false;
+            let timeoutTimer;
+            const clearRuntimeTimeout = () => {
+                if (timeoutTimer)
+                    clearTimeout(timeoutTimer);
+                timeoutTimer = undefined;
+            };
+            const armRuntimeTimeout = () => {
+                if (typeof input.timeoutMs !== "number" || timeoutTimer)
+                    return;
+                timeoutTimer = setTimeout(() => {
+                    if (!currentTurnId)
+                        return;
+                    const current = this.#turns.get(turnKey(input.sessionId, currentTurnId));
+                    if (current && isTerminalStatus(current.status))
+                        return;
+                    const message = `turn timed out after ${input.timeoutMs}ms`;
+                    this.#record({ type: "error", sessionId: input.sessionId, turnId: currentTurnId, message }, input);
+                    this.#record(completedEvent(input.sessionId, currentTurnId, "timeout", message), input);
+                    void this.#adapter.cancelTurn({ sessionId: input.sessionId, turnId: currentTurnId });
+                }, input.timeoutMs);
+            };
+            try {
+                for await (const raw of this.#adapter.startTurn(input)) {
+                    const event = this.#withContext(raw, input.sessionId, currentTurnId);
+                    const ref = eventToRef(this.#adapter.id, event, input.sessionId);
+                    if (ref && !currentTurnId) {
+                        currentTurnId = ref.turnId;
+                        armRuntimeTimeout();
+                    }
+                    this.#record(event, input);
+                    if (ref && !accepted) {
+                        accepted = true;
+                        onAccepted(ref);
+                    }
+                    if (event.type === "turn.completed") {
+                        terminalSeen = true;
+                        clearRuntimeTimeout();
+                    }
+                }
+                if (!accepted) {
+                    onRejected(new Error("provider turn ended without exposing a turn id"));
+                    return;
+                }
+                if (currentTurnId && !terminalSeen) {
+                    this.#record(completedEvent(input.sessionId, currentTurnId, "completed"), input);
+                }
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                if (!accepted) {
+                    onRejected(err);
+                    return;
+                }
+                if (currentTurnId) {
+                    this.#record({ type: "error", sessionId: input.sessionId, turnId: currentTurnId, message: err.message }, input);
+                    this.#record(completedEvent(input.sessionId, currentTurnId, "failed", err.message), input);
+                }
+            }
+            finally {
+                clearRuntimeTimeout();
+            }
+        })();
+    }
+    async #turnStatus(input) {
+        const turn = this.#turns.get(turnKey(input.sessionId, input.turnId));
+        if (!turn) {
+            return {
+                provider: this.#adapter.id,
+                sessionId: input.sessionId,
+                turnId: input.turnId,
+                status: "unknown",
+                eventCount: 0,
+            };
+        }
+        return snapshotTurn(turn);
+    }
+    async #waitTurn(input) {
+        const turn = this.#turns.get(turnKey(input.sessionId, input.turnId));
+        if (!turn)
+            throw new Error(`unknown turn: ${input.sessionId}/${input.turnId}`);
+        if (isTerminalStatus(turn.status))
+            return resultTurn(turn);
+        return new Promise((resolve, reject) => {
+            let timer;
+            const done = (result) => {
+                if (timer)
+                    clearTimeout(timer);
+                resolve(result);
+            };
+            turn.waiters.push(done);
+            if (typeof input.timeoutMs === "number") {
+                timer = setTimeout(() => {
+                    const index = turn.waiters.indexOf(done);
+                    if (index >= 0)
+                        turn.waiters.splice(index, 1);
+                    reject(new Error(`wait timed out after ${input.timeoutMs}ms`));
+                }, input.timeoutMs);
+            }
+        });
+    }
+    #events(input = {}) {
+        const queue = new AsyncQueue();
+        const replay = input.replay !== false;
+        if (replay) {
+            for (const event of this.#eventLog) {
+                if (event.seq > (input.afterSeq ?? 0) && eventMatches(event, input))
+                    queue.push(event);
+            }
+        }
+        const subscriber = { input, queue };
+        this.#subscribers.add(subscriber);
+        const subscribers = this.#subscribers;
+        return {
+            [Symbol.asyncIterator]() {
+                const iterator = queue[Symbol.asyncIterator]();
+                return {
+                    next: () => iterator.next(),
+                    return: async () => {
+                        subscribers.delete(subscriber);
+                        queue.close();
+                        return { value: undefined, done: true };
+                    },
+                };
+            },
+        };
+    }
+    async #cancelTurn(input) {
+        const cancelInput = { sessionId: input.sessionId, turnId: input.turnId };
+        await this.#adapter.cancelTurn(cancelInput);
+        const turn = this.#turns.get(turnKey(input.sessionId, input.turnId));
+        if (!turn || isTerminalStatus(turn.status))
+            return;
+        this.#record(completedEvent(input.sessionId, input.turnId, "cancelled"));
+    }
+    async #close() {
+        for (const session of this.#sessions.values()) {
+            session.status = "closed";
+            session.activeTurnIds.clear();
+            session.updatedAt = nowIso();
+        }
+        for (const subscriber of this.#subscribers)
+            subscriber.queue.close();
+        this.#subscribers.clear();
+        await this.#adapter.close();
+    }
+    #upsertSession(ref, status) {
+        const existing = this.#sessions.get(ref.id);
+        const updatedAt = nowIso();
+        if (existing) {
+            existing.ref = ref;
+            existing.status = existing.activeTurnIds.size > 0 && status !== "closed" ? "running" : status;
+            existing.updatedAt = updatedAt;
+            return existing;
+        }
+        const session = {
+            ref,
+            status,
+            createdAt: updatedAt,
+            updatedAt,
+            activeTurnIds: new Set(),
+        };
+        this.#sessions.set(ref.id, session);
+        return session;
+    }
+    #ensureSession(sessionId, status, recordedAt) {
+        const existing = this.#sessions.get(sessionId);
+        if (existing) {
+            if (existing.status !== "closed")
+                existing.status = status;
+            existing.updatedAt = recordedAt;
+            return existing;
+        }
+        const session = {
+            ref: { id: sessionId, provider: this.#adapter.id },
+            status,
+            createdAt: recordedAt,
+            updatedAt: recordedAt,
+            activeTurnIds: new Set(),
+        };
+        this.#sessions.set(sessionId, session);
+        return session;
+    }
+    #ensureTurn(ref, input, recordedAt) {
+        const key = turnKey(ref.sessionId, ref.turnId);
+        const existing = this.#turns.get(key);
+        if (existing) {
+            if (input && !existing.input)
+                existing.input = input;
+            return existing;
+        }
+        const turn = {
+            ref,
+            status: "running",
+            ...(input ? { input } : {}),
+            events: [],
+            text: "",
+            startedAt: recordedAt,
+            updatedAt: recordedAt,
+            waiters: [],
+        };
+        this.#turns.set(key, turn);
+        const session = this.#ensureSession(ref.sessionId, "running", recordedAt);
+        session.activeTurnIds.add(ref.turnId);
+        session.status = "running";
+        session.updatedAt = recordedAt;
+        return turn;
+    }
+    #record(event, input) {
+        const recorded = {
+            ...event,
+            seq: ++this.#seq,
+            recordedAt: nowIso(),
+        };
+        this.#eventLog.push(recorded);
+        this.#applyEvent(recorded, input);
+        for (const subscriber of this.#subscribers) {
+            if (recorded.seq > (subscriber.input.afterSeq ?? 0) && eventMatches(recorded, subscriber.input)) {
+                subscriber.queue.push(recorded);
+            }
+        }
+        return recorded;
+    }
+    #applyEvent(event, input) {
+        if (event.type === "session.started") {
+            this.#upsertSession({ id: event.sessionId, provider: this.#adapter.id, native: event.native }, "idle");
+            return;
+        }
+        const ref = eventToRef(this.#adapter.id, event, input?.sessionId);
+        if (!ref)
+            return;
+        const turn = this.#ensureTurn(ref, input, event.recordedAt);
+        turn.events.push(event);
+        turn.updatedAt = event.recordedAt;
+        if (event.type === "turn.started") {
+            turn.status = "running";
+            turn.startedAt = event.recordedAt;
+        }
+        else if (event.type === "message.delta") {
+            turn.text += event.text;
+        }
+        else if (event.type === "token.usage") {
+            turn.usage = event.usage;
+            if (event.totalUsage)
+                turn.totalUsage = event.totalUsage;
+            if ("contextWindow" in event)
+                turn.contextWindow = event.contextWindow;
+        }
+        else if (event.type === "error") {
+            turn.error = event.message;
+        }
+        else if (event.type === "turn.completed") {
+            if (!isTerminalStatus(turn.status)) {
+                turn.status = event.status;
+                turn.completedAt = event.recordedAt;
+                if (event.error)
+                    turn.error = event.error;
+                this.#finishTurn(turn);
+            }
+        }
+        const session = this.#ensureSession(ref.sessionId, "running", event.recordedAt);
+        if (isTerminalStatus(turn.status)) {
+            session.activeTurnIds.delete(ref.turnId);
+            if (session.status !== "closed")
+                session.status = session.activeTurnIds.size > 0 ? "running" : "idle";
+        }
+        else {
+            session.activeTurnIds.add(ref.turnId);
+            if (session.status !== "closed")
+                session.status = "running";
+        }
+        session.updatedAt = event.recordedAt;
+    }
+    #finishTurn(turn) {
+        const result = resultTurn(turn);
+        for (const waiter of turn.waiters.splice(0))
+            waiter(result);
+    }
+    #withContext(event, sessionId, turnId) {
+        if (event.type === "message.delta" || event.type === "reasoning.delta" || event.type === "tool.started" || event.type === "tool.completed" || event.type === "token.usage" || event.type === "error") {
+            return {
+                ...event,
+                sessionId: event.sessionId ?? sessionId,
+                ...(turnId && !event.turnId ? { turnId } : {}),
+            };
+        }
+        return event;
+    }
+}
+function eventToRef(provider, event, fallbackSessionId) {
+    if (!("turnId" in event) || !event.turnId)
+        return undefined;
+    const sessionId = "sessionId" in event && event.sessionId ? event.sessionId : fallbackSessionId;
+    if (!sessionId)
+        return undefined;
+    return { provider, sessionId, turnId: event.turnId };
+}
+function eventMatches(event, input) {
+    if (input.sessionId) {
+        if (!("sessionId" in event) || event.sessionId !== input.sessionId)
+            return false;
+    }
+    if (input.turnId) {
+        if (!("turnId" in event) || event.turnId !== input.turnId)
+            return false;
+    }
+    return true;
+}
+function snapshotSession(session) {
+    return {
+        ...session.ref,
+        status: session.status,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        activeTurnIds: [...session.activeTurnIds],
+    };
+}
+function snapshotTurn(turn) {
+    const runtimeOptions = turn.input ? resolveRuntimeOptions(turn.input) : {};
+    return {
+        ...turn.ref,
+        status: turn.status,
+        ...(runtimeOptions.cwd ? { cwd: runtimeOptions.cwd } : {}),
+        ...(runtimeOptions.model ? { model: runtimeOptions.model } : {}),
+        ...(turn.input?.options ? { options: turn.input.options } : {}),
+        ...(turn.usage ? { usage: turn.usage } : {}),
+        ...(turn.totalUsage ? { totalUsage: turn.totalUsage } : {}),
+        ...(turn.contextWindow !== undefined ? { contextWindow: turn.contextWindow } : {}),
+        ...(turn.startedAt ? { startedAt: turn.startedAt } : {}),
+        updatedAt: turn.updatedAt,
+        ...(turn.completedAt ? { completedAt: turn.completedAt } : {}),
+        ...(turn.error ? { error: turn.error } : {}),
+        eventCount: turn.events.length,
+    };
+}
+function resultTurn(turn) {
+    return {
+        ...snapshotTurn(turn),
+        text: turn.text,
+        events: [...turn.events],
+    };
+}
+function completedEvent(sessionId, turnId, status, error) {
+    return {
+        type: "turn.completed",
+        sessionId,
+        turnId,
+        status,
+        ...(error ? { error } : {}),
+    };
+}
+function isTerminalStatus(status) {
+    return status === "completed" || status === "failed" || status === "cancelled" || status === "timeout";
+}
+function turnKey(sessionId, turnId) {
+    return `${sessionId}\0${turnId}`;
+}
+function nowIso() {
+    return new Date().toISOString();
+}

package/dist/options.d.ts

@@ -0,0 +1,12 @@
+import type { ApprovalPolicy, ProviderId, ProviderRuntimeOptionsFor, RuntimeOptions, SandboxMode } from "./types.ts";
+export type RuntimeOptionCarrier<P extends ProviderId = ProviderId> = {
+    options?: RuntimeOptions<P>;
+    cwd?: string;
+    model?: string;
+    approvalPolicy?: ApprovalPolicy;
+    sandbox?: SandboxMode;
+};
+export declare function resolveRuntimeOptions<P extends ProviderId>(input?: RuntimeOptionCarrier<P>, defaults?: RuntimeOptions<P>): RuntimeOptions<P>;
+export declare function providerRuntimeOptions<P extends ProviderId>(options: RuntimeOptions<P>): ProviderRuntimeOptionsFor<P>;
+export declare function mergeRuntimeOptions<P extends ProviderId>(...items: Array<RuntimeOptions<P> | undefined>): RuntimeOptions<P>;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EACV,yBAAyB,EACzB,cAAc,EACd,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,IAAI;IACpE,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,UAAU,EACxD,KAAK,GAAE,oBAAoB,CAAC,CAAC,CAAM,EACnC,QAAQ,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GAC3B,cAAc,CAAC,CAAC,CAAC,CAEnB;AAED,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,UAAU,EACzD,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GACzB,yBAAyB,CAAC,CAAC,CAAC,CAE9B;AAED,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,UAAU,EAAE,GAAG,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAc3H"}

package/dist/options.js

@@ -0,0 +1,32 @@
+export function resolveRuntimeOptions(input = {}, defaults) {
+    return mergeRuntimeOptions(defaults, legacyRuntimeOptions(input), input.options);
+}
+export function providerRuntimeOptions(options) {
+    return options;
+}
+export function mergeRuntimeOptions(...items) {
+    const result = {};
+    for (const item of items) {
+        if (!item)
+            continue;
+        for (const [key, value] of Object.entries(item)) {
+            if (value === undefined)
+                continue;
+            if (key === "instructions") {
+                result.instructions = { ...result.instructions, ...item.instructions };
+            }
+            else {
+                result[key] = value;
+            }
+        }
+    }
+    return result;
+}
+function legacyRuntimeOptions(input) {
+    return {
+        ...(input.cwd ? { cwd: input.cwd } : {}),
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.approvalPolicy ? { approvalPolicy: input.approvalPolicy } : {}),
+        ...(input.sandbox ? { sandbox: input.sandbox } : {}),
+    };
+}

package/dist/port.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderAdapter } from "./providers/adapter.ts";
+import type { Port, ProviderId } from "./types.ts";
+export declare function createPortFromAdapter<P extends ProviderId>(adapter: ProviderAdapter<P>): Port<P>;
+//# sourceMappingURL=port.d.ts.map

package/dist/port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.d.ts","sourceRoot":"","sources":["../src/port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEnD,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,UAAU,EAAE,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAEhG"}

package/dist/port.js

@@ -0,0 +1,4 @@
+import { createLifecyclePort } from "./lifecycle.js";
+export function createPortFromAdapter(adapter) {
+    return createLifecyclePort(adapter);
+}

package/dist/provider-options.typecheck.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=provider-options.typecheck.d.ts.map

package/dist/provider-options.typecheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-options.typecheck.d.ts","sourceRoot":"","sources":["../src/provider-options.typecheck.ts"],"names":[],"mappings":""}

package/dist/provider-options.typecheck.js

@@ -0,0 +1,29 @@
+import { createPort } from "./index.js";
+void codexPort.sessions.create({
+    options: {
+        effort: "high",
+        config: { model_reasoning_effort: "high" },
+    },
+});
+void claudePort.sessions.create({
+    options: {
+        effort: "xhigh",
+        permissionMode: "plan",
+        thinking: { type: "adaptive", display: "summarized" },
+    },
+});
+const codexInput = {
+    provider: "codex",
+    options: {
+        effort: "minimal",
+        reasoningSummary: "concise",
+    },
+};
+void codexInput;
+// @ts-expect-error Claude-only options must not be accepted on a Codex port.
+void codexPort.sessions.create({ options: { permissionMode: "plan" } });
+// @ts-expect-error Provider-specific options are bound to createPort's selected provider.
+void createPort({ provider: "codex", options: { provider: "claude", permissionMode: "plan" } });
+// @ts-expect-error The public discriminated union must reject mismatched provider options.
+const invalidInput = { provider: "codex", options: { provider: "claude", permissionMode: "plan" } };
+void invalidInput;

package/dist/providers/adapter.d.ts

@@ -0,0 +1,14 @@
+import type { AgentEvent, CancelTurnInput, CapabilitySet, CreateSessionInput, ProviderId, SessionRef, StartTurnInput } from "../types.ts";
+export interface ProviderAdapter<P extends ProviderId = ProviderId> {
+    id: P;
+    capabilities: CapabilitySet<P>;
+    createSession(input?: CreateSessionInput<P>): Promise<SessionRef<P>>;
+    resumeSession(input: CreateSessionInput<P> & {
+        id: string;
+    }): Promise<SessionRef<P>>;
+    startTurn(input: StartTurnInput<P>): AsyncIterable<AgentEvent>;
+    cancelTurn(input: CancelTurnInput): Promise<void>;
+    events(): AsyncIterable<AgentEvent>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/providers/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/providers/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,UAAU,EACV,UAAU,EACV,cAAc,EACf,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU;IAChE,EAAE,EAAE,CAAC,CAAC;IACN,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAC/B,aAAa,CAAC,KAAK,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IACrE,aAAa,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IACrF,SAAS,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;IAC/D,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,MAAM,IAAI,aAAa,CAAC,UAAU,CAAC,CAAC;IACpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/dist/providers/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/claude.d.ts

@@ -0,0 +1,9 @@
+import type { CapabilitySet, CreatePortInputFor, Port, RuntimeOptions, StartTurnInput } from "../types.ts";
+import type { ProviderAdapter } from "./adapter.ts";
+type ClaudePortOptions = CreatePortInputFor<"claude">;
+export declare const claudeCapabilities: CapabilitySet<"claude">;
+export declare function createClaudePort(options: ClaudePortOptions): Promise<Port<"claude">>;
+export declare function createClaudeAdapter(options: ClaudePortOptions): Promise<ProviderAdapter<"claude">>;
+export declare function buildClaudeArgs(input: StartTurnInput<"claude">, defaults?: RuntimeOptions<"claude">): string[];
+export {};
+//# sourceMappingURL=claude.d.ts.map

package/dist/providers/claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/providers/claude.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAGV,aAAa,EACb,kBAAkB,EAGlB,IAAI,EACJ,cAAc,EAEd,cAAc,EAEf,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,KAAK,iBAAiB,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAC;AAEtD,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,QAAQ,CAwCtD,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAE1F;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAGxG;AA0ID,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,MAAM,EAAE,CAe9G"}