@love-moon/ai-sdk 0.3.1 → 0.4.0

package/dist/resume/chat-web.d.ts

@@ -0,0 +1,20 @@
+/**
+ * chat-web's "session" is a Chromium browser context, not a conversation id.
+ * There is no native resume primitive: closing and reopening produces a
+ * fresh ChatSession with a new in-memory chat. We satisfy ai-sdk's resume
+ * contract by surfacing a synthetic session id and a "best effort" context,
+ * but downstream callers should treat resume here as a no-op.
+ */
+export function buildCliArgs(sessionId: any): string[];
+export function findSessionPath(): Promise<null>;
+export function resolveResumeContext(sessionId: any, options?: {}): Promise<{
+    provider: any;
+    sessionId: any;
+    sessionPath: null;
+    cwd: any;
+    debugMetadata: {
+        cwdSource: any;
+        sessionPath: null;
+    };
+}>;
+export const BACKEND: "chat-web";

package/dist/resume/chat-web.js

@@ -0,0 +1,44 @@
+import { buildResumeContext, normalizeSessionId } from "./shared.js";
+export const BACKEND = "chat-web";
+/**
+ * chat-web's "session" is a Chromium browser context, not a conversation id.
+ * There is no native resume primitive: closing and reopening produces a
+ * fresh ChatSession with a new in-memory chat. We satisfy ai-sdk's resume
+ * contract by surfacing a synthetic session id and a "best effort" context,
+ * but downstream callers should treat resume here as a no-op.
+ */
+export function buildCliArgs(sessionId) {
+    // chat-web has no CLI to pass these args to (it's an in-process SDK), but
+    // the resume contract requires every backend to return a non-empty arg
+    // vector so downstream resume dispatch stays uniform. We emit a stable,
+    // recognisable token; consumers should ignore it for chat-web.
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return [];
+    }
+    return [`--resume-session-id=${normalizedSessionId}`];
+}
+export async function findSessionPath() {
+    // No on-disk JSONL session file — the persistent state lives in the
+    // browser profile dir, but that's not what callers expect from this hook.
+    return null;
+}
+export async function resolveResumeContext(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        throw new Error("--resume requires a session id");
+    }
+    const cwd = typeof options?.cwd === "string" && options.cwd.trim()
+        ? options.cwd.trim()
+        : process.cwd();
+    return buildResumeContext({
+        provider: "chat-web",
+        sessionId: normalizedSessionId,
+        sessionPath: null,
+        cwd,
+        cwdSource: "process_cwd",
+        extraDebug: {
+            note: "chat-web does not support cross-process conversation resume; a fresh ChatSession will be opened.",
+        },
+    });
+}

package/dist/resume/index.js

@@ -1,5 +1,6 @@
 import { BUILT_IN_BACKENDS, getBuiltInBackendEntry, normalizeBuiltInBackend, } from "../built-in-backends.js";
 import { getExternalProviderDescriptor, resolveExternalBackend, } from "../external-provider-registry.js";
+import * as chatWeb from "./chat-web.js";
 import * as claude from "./claude.js";
 import * as codex from "./codex.js";
 import * as copilot from "./copilot.js";
@@ -25,6 +26,7 @@ const RESUME_MODULES_BY_BACKEND = new Map([
     ["copilot", copilot],
     ["kimi", kimi],
     ["opencode", opencode],
+    ["chat-web", chatWeb],
 ]);
 // Sanity-check at module load:
 // (1) Every registered resume module must point at a real built-in backend.

package/dist/session-factory.d.ts

@@ -10,7 +10,9 @@ export const COPILOT_PROVIDER_VARIANT: "copilot-sdk";
 export const KIMI_PROVIDER_VARIANT: "kimi-cli-wire";
 export const KIMI_PRINT_PROVIDER_VARIANT: "kimi-cli-print";
 export const OPENCODE_PROVIDER_VARIANT: "opencode-sdk";
+export const CHAT_WEB_PROVIDER_VARIANT: "chat-web-session";
 import { BUILT_IN_BACKENDS } from "./built-in-backends.js";
+import { ChatWebSession } from "./providers/chat-web-session.js";
 import { CodexAppServerSession } from "./providers/codex-app-server-session.js";
 import { CodexExecSession } from "./providers/codex-exec-session.js";
 import { ClaudeAgentSdkSession } from "./providers/claude-agent-sdk-session.js";
@@ -18,4 +20,4 @@ import { CopilotSdkSession } from "./providers/copilot-sdk-session.js";
 import { KimiCliSession } from "./providers/kimi-cli-session.js";
 import { KimiPrintSession } from "./providers/kimi-print-session.js";
 import { OpencodeSdkSession } from "./providers/opencode-sdk-session.js";
-export { BUILT_IN_BACKENDS, CodexAppServerSession, CodexExecSession, ClaudeAgentSdkSession, CopilotSdkSession, KimiCliSession, KimiPrintSession, OpencodeSdkSession };
+export { BUILT_IN_BACKENDS, ChatWebSession, CodexAppServerSession, CodexExecSession, ClaudeAgentSdkSession, CopilotSdkSession, KimiCliSession, KimiPrintSession, OpencodeSdkSession };

package/dist/session-factory.js

@@ -1,4 +1,5 @@
-import { BUILT_IN_BACKENDS, CLAUDE_AGENT_SDK_VARIANT, CODEX_APP_SERVER_VARIANT, CODEX_EXEC_VARIANT, COPILOT_SDK_VARIANT, KIMI_CLI_PRINT_VARIANT, KIMI_CLI_WIRE_VARIANT, OPENCODE_SDK_VARIANT, getBuiltInBackendEntry, isBuiltInBackend, listBuiltInBackends, normalizeBuiltInBackend, } from "./built-in-backends.js";
+import { BUILT_IN_BACKENDS, CHAT_WEB_SESSION_VARIANT, CLAUDE_AGENT_SDK_VARIANT, CODEX_APP_SERVER_VARIANT, CODEX_EXEC_VARIANT, COPILOT_SDK_VARIANT, KIMI_CLI_PRINT_VARIANT, KIMI_CLI_WIRE_VARIANT, OPENCODE_SDK_VARIANT, getBuiltInBackendEntry, isBuiltInBackend, listBuiltInBackends, normalizeBuiltInBackend, } from "./built-in-backends.js";
+import { ChatWebSession } from "./providers/chat-web-session.js";
 import { CodexAppServerSession } from "./providers/codex-app-server-session.js";
 import { CodexExecSession } from "./providers/codex-exec-session.js";
 import { ClaudeAgentSdkSession } from "./providers/claude-agent-sdk-session.js";
@@ -14,12 +15,22 @@ export const COPILOT_PROVIDER_VARIANT = COPILOT_SDK_VARIANT;
 export const KIMI_PROVIDER_VARIANT = KIMI_CLI_WIRE_VARIANT;
 export const KIMI_PRINT_PROVIDER_VARIANT = KIMI_CLI_PRINT_VARIANT;
 export const OPENCODE_PROVIDER_VARIANT = OPENCODE_SDK_VARIANT;
+export const CHAT_WEB_PROVIDER_VARIANT = CHAT_WEB_SESSION_VARIANT;
 const SESSION_FACTORIES_BY_BACKEND = new Map([
     [
         "codex",
-        (backend, options) => hasStructuredOutputPreference(options)
-            ? new CodexExecSession(backend, options)
-            : new CodexAppServerSession(backend, options),
+        (backend, options) => {
+            // Goal mode requires the app-server transport (codex-exec has no
+            // `thread/goal/set` JSON-RPC). When goalMode is requested we always
+            // pick the app-server variant, even if a structured-output preference
+            // would otherwise route to codex-exec.
+            if (options?.goalMode === true) {
+                return new CodexAppServerSession(backend, options);
+            }
+            return hasStructuredOutputPreference(options)
+                ? new CodexExecSession(backend, options)
+                : new CodexAppServerSession(backend, options);
+        },
     ],
     ["claude", (backend, options) => new ClaudeAgentSdkSession(backend, options)],
     ["copilot", (backend, options) => new CopilotSdkSession(backend, options)],
@@ -30,6 +41,7 @@ const SESSION_FACTORIES_BY_BACKEND = new Map([
             : new KimiCliSession(backend, options),
     ],
     ["opencode", (backend, options) => new OpencodeSdkSession(backend, options)],
+    ["chat-web", (backend, options) => new ChatWebSession(backend, options)],
 ]);
 function hasStructuredOutputPreference(options = {}) {
     if (!options || typeof options !== "object") {
@@ -106,6 +118,7 @@ export async function createLocalAiSession(backend, options = {}) {
     return await descriptor.createSession(normalized, options);
 }
 export { BUILT_IN_BACKENDS };
+export { ChatWebSession };
 export { CodexAppServerSession };
 export { CodexExecSession };
 export { ClaudeAgentSdkSession };

package/dist/shared.d.ts

@@ -1,3 +1,21 @@
+/**
+ * @param {unknown} value
+ * @returns {value is GoalStatus}
+ */
+export function isGoalStatus(value: unknown): value is GoalStatus;
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export function isTerminalGoalStatus(value: unknown): boolean;
+/**
+ * Resolve a session's capability snapshot, falling back to
+ * {@link DEFAULT_SESSION_CAPABILITIES}.
+ *
+ * @param {unknown} session
+ * @returns {SessionCapabilities}
+ */
+export function resolveSessionCapabilities(session: unknown): SessionCapabilities;
 export function normalizeLogger(logger: any): any;
 export function emitLog(logger: any, message: any): void;
 export function truncateText(value: any, maxLen?: number): string;
@@ -16,3 +34,144 @@ export function proxyToEnv(envConfig: any): {};
 export function withoutCopilotGithubTokenEnv(env: any): any;
 export function serializeError(error: any): any;
 export function reviveError(payload: any): Error;
+/**
+ * Goal-mode capability typedefs shared by AI SDK providers that implement
+ * the optional {@link runGoal} method.
+ *
+ * Callers should treat goal support as opt-in: detect with
+ * `typeof session.runGoal === "function"`. When unsupported, do NOT silently
+ * fall back to {@link runTurn} — surface a clear error instead.
+ *
+ * Session creation may also accept `{ goalMode: true }` so the underlying
+ * transport can adjust its spawn arguments (e.g. Codex app-server requires
+ * `--enable goals` at boot time; dynamic enablement is not supported).
+ *
+ * @typedef {"active"|"paused"|"blocked"|"usageLimited"|"budgetLimited"|"complete"} GoalStatus
+ *
+ * @typedef {Object} GoalRequest
+ * @property {string} objective
+ * @property {number|null} [tokenBudget]
+ * @property {{ type: "issue"|"manual", issueId?: string, taskId?: string }} [source]
+ *
+ * @typedef {Object} GoalState
+ * @property {string} [id]
+ * @property {string} [threadId]
+ * @property {string} objective
+ * @property {GoalStatus} status
+ * @property {number|null} [tokenBudget]
+ *
+ * @typedef {Object} GoalResult
+ * @property {string} text
+ * @property {GoalState} goal
+ * @property {unknown} [usage]
+ * @property {Record<string, unknown>} [metadata]
+ */
+/**
+ * Runtime list of valid {@link GoalStatus} values. Useful for validation.
+ * Terminal statuses are everything except "active" and "paused".
+ * @type {ReadonlyArray<GoalStatus>}
+ */
+export const GOAL_STATUSES: ReadonlyArray<GoalStatus>;
+/**
+ * Terminal goal statuses (the goal will not produce further updates).
+ * @type {ReadonlyArray<GoalStatus>}
+ */
+export const TERMINAL_GOAL_STATUSES: ReadonlyArray<GoalStatus>;
+/**
+ * Session capability flags advertised in {@link SessionSnapshot.capabilities}.
+ *
+ * Providers may declare optional features (e.g. `goal`) so that callers can
+ * detect support without reflecting on method names (which is unreliable when
+ * a wrapping proxy unconditionally forwards every method).
+ *
+ * @typedef {Object} SessionCapabilities
+ * @property {boolean} [goal]
+ */
+/**
+ * Default capabilities assigned to providers that do not opt into any optional
+ * feature. Treat the returned object as read-only; clone before mutating.
+ *
+ * @type {Readonly<SessionCapabilities>}
+ */
+export const DEFAULT_SESSION_CAPABILITIES: Readonly<SessionCapabilities>;
+/**
+ * Goal-mode capability typedefs shared by AI SDK providers that implement
+ * the optional {@link runGoal} method.
+ *
+ * Callers should treat goal support as opt-in: detect with
+ * `typeof session.runGoal === "function"`. When unsupported, do NOT silently
+ * fall back to {@link runTurn} — surface a clear error instead.
+ *
+ * Session creation may also accept `{ goalMode: true }` so the underlying
+ * transport can adjust its spawn arguments (e.g. Codex app-server requires
+ * `--enable goals` at boot time; dynamic enablement is not supported).
+ */
+export type GoalStatus = "active" | "paused" | "blocked" | "usageLimited" | "budgetLimited" | "complete";
+/**
+ * Goal-mode capability typedefs shared by AI SDK providers that implement
+ * the optional {@link runGoal} method.
+ *
+ * Callers should treat goal support as opt-in: detect with
+ * `typeof session.runGoal === "function"`. When unsupported, do NOT silently
+ * fall back to {@link runTurn} — surface a clear error instead.
+ *
+ * Session creation may also accept `{ goalMode: true }` so the underlying
+ * transport can adjust its spawn arguments (e.g. Codex app-server requires
+ * `--enable goals` at boot time; dynamic enablement is not supported).
+ */
+export type GoalRequest = {
+    objective: string;
+    tokenBudget?: number | null | undefined;
+    source?: {
+        type: "issue" | "manual";
+        issueId?: string;
+        taskId?: string;
+    } | undefined;
+};
+/**
+ * Goal-mode capability typedefs shared by AI SDK providers that implement
+ * the optional {@link runGoal} method.
+ *
+ * Callers should treat goal support as opt-in: detect with
+ * `typeof session.runGoal === "function"`. When unsupported, do NOT silently
+ * fall back to {@link runTurn} — surface a clear error instead.
+ *
+ * Session creation may also accept `{ goalMode: true }` so the underlying
+ * transport can adjust its spawn arguments (e.g. Codex app-server requires
+ * `--enable goals` at boot time; dynamic enablement is not supported).
+ */
+export type GoalState = {
+    id?: string | undefined;
+    threadId?: string | undefined;
+    objective: string;
+    status: GoalStatus;
+    tokenBudget?: number | null | undefined;
+};
+/**
+ * Goal-mode capability typedefs shared by AI SDK providers that implement
+ * the optional {@link runGoal} method.
+ *
+ * Callers should treat goal support as opt-in: detect with
+ * `typeof session.runGoal === "function"`. When unsupported, do NOT silently
+ * fall back to {@link runTurn} — surface a clear error instead.
+ *
+ * Session creation may also accept `{ goalMode: true }` so the underlying
+ * transport can adjust its spawn arguments (e.g. Codex app-server requires
+ * `--enable goals` at boot time; dynamic enablement is not supported).
+ */
+export type GoalResult = {
+    text: string;
+    goal: GoalState;
+    usage?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+};
+/**
+ * Session capability flags advertised in {@link SessionSnapshot.capabilities}.
+ *
+ * Providers may declare optional features (e.g. `goal`) so that callers can
+ * detect support without reflecting on method names (which is unreliable when
+ * a wrapping proxy unconditionally forwards every method).
+ */
+export type SessionCapabilities = {
+    goal?: boolean | undefined;
+};

package/dist/shared.js

@@ -2,6 +2,117 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import yaml from "js-yaml";
+/**
+ * Goal-mode capability typedefs shared by AI SDK providers that implement
+ * the optional {@link runGoal} method.
+ *
+ * Callers should treat goal support as opt-in: detect with
+ * `typeof session.runGoal === "function"`. When unsupported, do NOT silently
+ * fall back to {@link runTurn} — surface a clear error instead.
+ *
+ * Session creation may also accept `{ goalMode: true }` so the underlying
+ * transport can adjust its spawn arguments (e.g. Codex app-server requires
+ * `--enable goals` at boot time; dynamic enablement is not supported).
+ *
+ * @typedef {"active"|"paused"|"blocked"|"usageLimited"|"budgetLimited"|"complete"} GoalStatus
+ *
+ * @typedef {Object} GoalRequest
+ * @property {string} objective
+ * @property {number|null} [tokenBudget]
+ * @property {{ type: "issue"|"manual", issueId?: string, taskId?: string }} [source]
+ *
+ * @typedef {Object} GoalState
+ * @property {string} [id]
+ * @property {string} [threadId]
+ * @property {string} objective
+ * @property {GoalStatus} status
+ * @property {number|null} [tokenBudget]
+ *
+ * @typedef {Object} GoalResult
+ * @property {string} text
+ * @property {GoalState} goal
+ * @property {unknown} [usage]
+ * @property {Record<string, unknown>} [metadata]
+ */
+/**
+ * Runtime list of valid {@link GoalStatus} values. Useful for validation.
+ * Terminal statuses are everything except "active" and "paused".
+ * @type {ReadonlyArray<GoalStatus>}
+ */
+export const GOAL_STATUSES = Object.freeze([
+    "active",
+    "paused",
+    "blocked",
+    "usageLimited",
+    "budgetLimited",
+    "complete",
+]);
+/**
+ * Terminal goal statuses (the goal will not produce further updates).
+ * @type {ReadonlyArray<GoalStatus>}
+ */
+export const TERMINAL_GOAL_STATUSES = Object.freeze([
+    "blocked",
+    "usageLimited",
+    "budgetLimited",
+    "complete",
+]);
+/**
+ * @param {unknown} value
+ * @returns {value is GoalStatus}
+ */
+export function isGoalStatus(value) {
+    return typeof value === "string" && GOAL_STATUSES.includes(/** @type {GoalStatus} */ (value));
+}
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export function isTerminalGoalStatus(value) {
+    return typeof value === "string" && TERMINAL_GOAL_STATUSES.includes(/** @type {GoalStatus} */ (value));
+}
+/**
+ * Session capability flags advertised in {@link SessionSnapshot.capabilities}.
+ *
+ * Providers may declare optional features (e.g. `goal`) so that callers can
+ * detect support without reflecting on method names (which is unreliable when
+ * a wrapping proxy unconditionally forwards every method).
+ *
+ * @typedef {Object} SessionCapabilities
+ * @property {boolean} [goal]
+ */
+/**
+ * Default capabilities assigned to providers that do not opt into any optional
+ * feature. Treat the returned object as read-only; clone before mutating.
+ *
+ * @type {Readonly<SessionCapabilities>}
+ */
+export const DEFAULT_SESSION_CAPABILITIES = Object.freeze({ goal: false });
+/**
+ * Resolve a session's capability snapshot, falling back to
+ * {@link DEFAULT_SESSION_CAPABILITIES}.
+ *
+ * @param {unknown} session
+ * @returns {SessionCapabilities}
+ */
+export function resolveSessionCapabilities(session) {
+    if (session && typeof session === "object") {
+        const obj = /** @type {Record<string, unknown>} */ (session);
+        if (typeof obj.getCapabilities === "function") {
+            const raw = /** @type {() => unknown} */ (obj.getCapabilities).call(session);
+            if (raw && typeof raw === "object") {
+                return { ...DEFAULT_SESSION_CAPABILITIES, ...raw };
+            }
+        }
+        const constructor = /** @type {{ capabilities?: unknown }} */ ((session.constructor && typeof session.constructor === "function"
+            ? session.constructor
+            : null) || {});
+        if (constructor && constructor.capabilities && typeof constructor.capabilities === "object") {
+            return { ...DEFAULT_SESSION_CAPABILITIES, ...constructor.capabilities };
+        }
+    }
+    return { ...DEFAULT_SESSION_CAPABILITIES };
+}
 export function normalizeLogger(logger) {
     if (typeof logger === "function") {
         return { log: logger };

package/dist/transports/codex-app-server-transport.d.ts

@@ -4,6 +4,7 @@ export class CodexAppServerTransport extends EventEmitter<[never]> {
     logger: any;
     cwd: any;
     command: string;
+    enableGoals: boolean;
     args: string[];
     env: any;
     ignoreCodexApiKey: boolean;

package/dist/transports/codex-app-server-transport.js

@@ -3,6 +3,49 @@ import { spawn } from "node:child_process";
 import readline from "node:readline";
 import { emitLog, normalizeLogger, parseCommandParts, sanitizeForLog, serializeError, } from "../shared.js";
 const DEFAULT_CODEX_APP_SERVER_COMMAND = "codex app-server --listen stdio://";
+/**
+ * Add `--enable goals` to the codex app-server spawn args when goal mode is
+ * requested. Dynamic enablement via `experimentalFeature/enablement/set` is
+ * NOT supported by codex, so the feature must be enabled at boot. Idempotent:
+ * does not double-add when the user already passed any of the supported
+ * spellings (`--enable goals`, `--enable=goals`, `--enable=goals,foo`) in the
+ * command line.
+ *
+ * @param {string[]} args
+ * @param {boolean} enableGoals
+ * @returns {string[]}
+ */
+function injectEnableGoalsArgs(args, enableGoals) {
+    const normalized = Array.isArray(args) ? [...args] : [];
+    if (!enableGoals) {
+        return normalized;
+    }
+    for (let index = 0; index < normalized.length; index += 1) {
+        const token = normalized[index];
+        if (typeof token !== "string") {
+            continue;
+        }
+        // Two-token form: ["--enable", "goals"]
+        if (token === "--enable" && normalized[index + 1] === "goals") {
+            return normalized;
+        }
+        // Equals form: "--enable=goals" or comma list "--enable=goals,foo"
+        if (token.startsWith("--enable=")) {
+            const value = token.slice("--enable=".length);
+            const features = value
+                .split(",")
+                .map((entry) => entry.trim().toLowerCase())
+                .filter(Boolean);
+            if (features.includes("goals")) {
+                return normalized;
+            }
+        }
+    }
+    const listenIndex = normalized.indexOf("--listen");
+    const insertAt = listenIndex >= 0 ? listenIndex : normalized.length;
+    normalized.splice(insertAt, 0, "--enable", "goals");
+    return normalized;
+}
 function createRpcError(payload) {
     const message = String(payload?.message || payload?.error?.message || "Codex app-server request failed");
     const error = new Error(message);
@@ -34,7 +77,8 @@ export class CodexAppServerTransport extends EventEmitter {
             throw new Error("Invalid codex app-server command");
         }
         this.command = command;
-        this.args = args;
+        this.enableGoals = options.enableGoals === true;
+        this.args = injectEnableGoalsArgs(args, this.enableGoals);
         this.env = options.env && typeof options.env === "object" ? { ...options.env } : {};
         this.ignoreCodexApiKey = options.ignoreCodexApiKey === true;
         this.child = null;

package/dist/worker.js

@@ -1,7 +1,21 @@
 #!/usr/bin/env node
 import readline from "node:readline";
 import { createLocalAiSession } from "./session-factory.js";
-import { serializeError } from "./shared.js";
+import { DEFAULT_SESSION_CAPABILITIES, resolveSessionCapabilities, serializeError, } from "./shared.js";
+function buildReadySnapshot(aiSession) {
+    const snapshot = typeof aiSession?.getSnapshot === "function" ? aiSession.getSnapshot() : null;
+    const base = snapshot && typeof snapshot === "object" ? { ...snapshot } : {};
+    // Always include a capabilities field so the parent process can do the
+    // declarative `capabilities.goal === false` short-circuit without needing
+    // to inspect method names through the IPC boundary.
+    if (!base.capabilities || typeof base.capabilities !== "object") {
+        base.capabilities = resolveSessionCapabilities(aiSession);
+    }
+    else {
+        base.capabilities = { ...DEFAULT_SESSION_CAPABILITIES, ...base.capabilities };
+    }
+    return base;
+}
 let session = null;
 let sessionCreated = false;
 function send(payload) {
@@ -48,7 +62,7 @@ async function handleCreate(message) {
     attachSessionEvents(session);
     send({
         type: "ready",
-        snapshot: typeof session.getSnapshot === "function" ? session.getSnapshot() : null,
+        snapshot: buildReadySnapshot(session),
         workerPid: process.pid,
         workerProcessPid: process.pid,
     });
@@ -62,8 +76,8 @@ async function handleRequest(message) {
         throw new Error(`Unsupported worker method: ${method}`);
     }
     const args = Array.isArray(message.args) ? [...message.args] : [];
-    if (method === "runTurn") {
-        const prompt = args[0];
+    if (method === "runTurn" || method === "runGoal") {
+        const firstArg = args[0];
         const options = args[1] && typeof args[1] === "object" ? { ...args[1] } : {};
         options.onProgress = (payload) => {
             send({
@@ -72,7 +86,7 @@ async function handleRequest(message) {
                 payload,
             });
         };
-        args[0] = prompt;
+        args[0] = firstArg;
         args[1] = options;
     }
     const result = await session[method](...args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -18,7 +18,9 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "node --test",
+    "test": "npm run test:js && npm run test:manager",
+    "test:js": "node --import tsx --test test/*.test.js",
+    "test:manager": "node --import tsx --test test/manager/*.test.ts",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
@@ -26,11 +28,16 @@
     "@github/copilot-sdk": "^0.2.2",
     "@opencode-ai/sdk": "^1.2.25",
     "js-yaml": "^4.1.1",
+    "yaml": "^2.5.1",
     "zod": "^4.1.5"
   },
+  "optionalDependencies": {
+    "@love-moon/chat-web": "^0.4.0"
+  },
   "devDependencies": {
     "@types/node": "^22.10.2",
+    "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "03b4582"
+  "gitCommitId": "2d1526c"
 }