@justin06lee/yagami 0.4.1

package/dist/index.d.ts

@@ -0,0 +1,328 @@
+import { A as ApiError, P as Provider, a as ProviderCapabilities, T as TurnRequest, b as TurnEvent, E as EngineModel } from './engine-pmCK3S7z.js';
+export { c as ApiErrorType, C as CodexProvider, d as CodexProviderOptions, e as CodexSandboxMode, f as CompleteResult, g as ContentBlock, h as ContentBlockParam, D as DetectedProvider, i as EngineOptions, L as LoadedProviders, M as MessageParam, j as MessagesRequest, k as MessagesResponse, l as ModelRef, m as PROVIDER_PRESETS, n as ProviderConfigEntry, o as ProviderKind, p as ProviderPreset, S as SessionCache, q as SessionCacheOptions, r as SseEvent, s as StreamOptions, t as StreamResultInfo, u as StreamStart, v as SystemParam, U as Usage, Y as YagamiEngine, w as createProvider, x as detectProviders, y as loadProviders, z as parseModelRef, B as presetFor, F as qualifiedModel } from './engine-pmCK3S7z.js';
+import { Options, SDKUserMessage, Query, SettingSource, PermissionUpdate, CanUseTool, PermissionResult, SDKMessage } from '@anthropic-ai/claude-agent-sdk';
+export { Options as AgentOptions, CanUseTool, PermissionMode, Query, SDKMessage, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import { ClientSideConnection, InitializeResponse, SessionNotification, RequestPermissionRequest, RequestPermissionResponse } from '@agentclientprotocol/sdk';
+
+interface ClaudeSessionOptions {
+    /** Path to the `claude` binary. Auto-resolved when omitted. */
+    claudePath?: string;
+    /** Agent SDK options; merged over yagami's defaults. */
+    options?: Options;
+}
+/**
+ * Full agentic Claude Code session (tools, permissions, plan mode — the
+ * works), backed by the user's installed, signed-in CLI. This is the
+ * embeddable "what T3 Code does" primitive for building UIs on top of
+ * Claude Code: unlike the Messages-API engine, nothing is restricted here.
+ *
+ * Defaults to the `claude_code` system prompt preset so behavior matches the
+ * interactive CLI; pass `options.systemPrompt` to override.
+ */
+declare function claudeCodeSession(prompt: string | AsyncIterable<SDKUserMessage>, sessionOptions?: ClaudeSessionOptions): Query;
+
+/**
+ * How closely an embedded session should mirror the interactive `claude`
+ * terminal. This resolves the single most common surprise in library mode:
+ * the Agent SDK loads none of your settings by default.
+ *
+ * - `"terminal"` — behave like your CLI: load user + project + local
+ *   settings, so CLAUDE.md, skills, hooks, and .mcp.json all apply.
+ * - `"isolated"` — load nothing (the raw SDK default); the app supplies
+ *   everything explicitly. Best when the session must be reproducible or
+ *   must not pick up the developer's personal config.
+ * - `"project"` — load project + local settings but not the user's global
+ *   ones: shared repo config without personal CLAUDE.md/skills.
+ */
+type Parity = "terminal" | "project" | "isolated";
+/** The `settingSources` a parity level maps to. */
+declare function settingSourcesFor(parity: Parity): SettingSource[];
+
+/** A tool-use request handed to the host for a decision. */
+interface PermissionRequest {
+    toolName: string;
+    input: Record<string, unknown>;
+    signal: AbortSignal;
+    /**
+     * Suggested permission updates the host can echo back to stop being asked
+     * again this session (e.g. behind an "always allow" button).
+     */
+    suggestions?: PermissionUpdate[];
+}
+/**
+ * The host's answer. `allow` optionally rewrites the tool input and/or
+ * persists permission updates for the rest of the session; `deny` carries a
+ * message the model sees and can optionally interrupt the turn.
+ */
+type PermissionDecision = {
+    behavior: "allow";
+    updatedInput?: Record<string, unknown>;
+    updatedPermissions?: PermissionUpdate[];
+} | {
+    behavior: "deny";
+    message?: string;
+    interrupt?: boolean;
+};
+/** What the app implements: show UI, return a decision. */
+type PermissionHandler = (req: PermissionRequest) => PermissionDecision | Promise<PermissionDecision>;
+interface PermissionAdapterOptions {
+    /**
+     * Decision used when no handler is set, a handler throws, or the request is
+     * aborted. Defaults to denying — the safe choice for an unattended host.
+     */
+    fallback?: "allow" | "deny";
+    /** Tool names to auto-allow without ever calling the handler. */
+    autoAllow?: Iterable<string>;
+    /** Tool names to auto-deny without ever calling the handler. */
+    autoDeny?: Iterable<string>;
+}
+/**
+ * Turns a host-supplied {@link PermissionHandler} into the Agent SDK's
+ * {@link CanUseTool} callback, owning the state machine so the app only has
+ * to answer one question: allow or deny this tool call?
+ *
+ * The policy (what to auto-approve) stays with the app — yagami never bakes
+ * in a permissive default. Without a handler, everything falls back (deny by
+ * default), so a session is safe before the UI is wired up.
+ */
+declare class PermissionAdapter {
+    private handler;
+    private readonly fallback;
+    private readonly autoAllow;
+    private readonly autoDeny;
+    constructor(options?: PermissionAdapterOptions);
+    /** Install (or replace) the host decision callback. */
+    setHandler(handler: PermissionHandler | undefined): void;
+    allowTool(toolName: string): void;
+    denyTool(toolName: string): void;
+    private fallbackResult;
+    /**
+     * The callback to hand to `claudeCodeSession`/the Agent SDK. Typed to
+     * always resolve (never null), and assignable to the SDK's CanUseTool.
+     */
+    readonly canUseTool: (...args: Parameters<CanUseTool>) => Promise<PermissionResult>;
+}
+
+interface AgentSessionOptions {
+    /** Path to the `claude` binary. Auto-resolved when omitted. */
+    claudePath?: string;
+    /** Project directory the agent works in. */
+    cwd?: string;
+    /** How closely to mirror the interactive terminal (default "terminal"). */
+    parity?: Parity;
+    /** Model id/alias; the CLI default when omitted. */
+    model?: string;
+    /** Host permission callback (see {@link PermissionAdapter}). */
+    onPermission?: PermissionHandler;
+    /** Options for the permission adapter (fallback, auto-allow/deny). */
+    permission?: PermissionAdapterOptions;
+    /** Reported to the CLI as the client application (e.g. your app name). */
+    appName?: string;
+    /** Extra Agent SDK options, merged last (wins over the above). */
+    options?: Options;
+}
+/**
+ * A long-lived, agentic Claude Code session for building a UI on top of the
+ * CLI — the ruri use case. It keeps one warm process across turns (so only
+ * the first turn pays cold-start), threads permission decisions to a host
+ * callback, mirrors your terminal settings by default, and exposes the
+ * lifecycle the interactive CLI gives you for free: send, interrupt, resume,
+ * change model/permission mode, close.
+ *
+ * Everything the model produces is an {@link SDKMessage} you render yourself.
+ */
+declare class AgentSession implements AsyncIterable<SDKMessage> {
+    readonly permissions: PermissionAdapter;
+    private readonly claudePath;
+    private readonly appName;
+    private readonly baseOptions;
+    private readonly input;
+    private query;
+    private started;
+    private closed;
+    private currentSessionId;
+    constructor(options?: AgentSessionOptions);
+    /** Set (or clear) the host permission callback after construction. */
+    setPermissionHandler(handler: PermissionHandler | undefined): void;
+    /** The live Claude Code session id, once the first turn has started. */
+    get sessionId(): string | undefined;
+    /** Queue a user turn. The process starts on the first send and stays warm. */
+    send(text: string, options?: {
+        images?: Array<{
+            data: string;
+            mediaType?: string;
+        }>;
+    }): void;
+    private ensureStarted;
+    /** Iterate every SDK message the agent produces across all turns. */
+    [Symbol.asyncIterator](): AsyncIterator<SDKMessage>;
+    /** Interrupt the in-flight turn (the CLI's Esc/Ctrl-C). */
+    interrupt(): Promise<void>;
+    /** Switch models mid-session (the CLI's /model). */
+    setModel(model: string): Promise<void>;
+    /** Switch permission mode mid-session (default/acceptEdits/plan/bypassPermissions). */
+    setPermissionMode(mode: "default" | "acceptEdits" | "plan" | "bypassPermissions"): Promise<void>;
+    /** Models the CLI reports as available (for a picker). */
+    supportedModels(): Promise<Array<{
+        value: string;
+        displayName: string;
+    }>>;
+    /** End the session and tear down the process. */
+    close(): void;
+}
+/**
+ * Convenience: start an {@link AgentSession} and immediately send one turn.
+ * Returns the session so callers can iterate it, interrupt, or send more.
+ */
+declare function startAgentSession(prompt: string, options?: AgentSessionOptions): AgentSession;
+
+/** Base class for typed yagami failures — every subclass carries a stable `code`. */
+declare class YagamiError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/** The provider's CLI could not be found on this machine. */
+declare class ProviderNotInstalledError extends YagamiError {
+    readonly provider: string;
+    readonly installHint: string;
+    constructor(provider: string, installHint: string, detail?: string);
+}
+/** The provider's CLI is installed but not logged in (or its login expired). */
+declare class AuthRequiredError extends YagamiError {
+    readonly provider: string;
+    readonly loginCommand: string;
+    constructor(provider: string, loginCommand: string, detail?: string);
+}
+/** The provider ran but failed — process crash, protocol error, engine error. */
+declare class ProviderError extends YagamiError {
+    readonly provider: string;
+    constructor(provider: string, message: string);
+}
+/** Result of comparing an SDK build against the CLI binary it drives. */
+interface VersionSkew {
+    sdkVersion: string;
+    binaryVersion: string;
+    inSync: boolean;
+    note: string;
+}
+/** Map any failure onto the Anthropic-shaped HTTP error the API returns. */
+declare function toApiError(err: unknown): ApiError;
+
+interface ClaudeProviderOptions {
+    /** Path to the `claude` binary. Auto-resolved when omitted. */
+    path?: string;
+    /** Optional CLAUDE_CONFIG_DIR override for the spawned CLI. */
+    configDir?: string;
+    /** Working directory for completion turns (inert — tools are disabled). */
+    workDir?: string;
+    /** Reported to the CLI as the client application. */
+    appName?: string;
+}
+/** Claude Code through the Agent SDK, pointed at the user's signed-in binary. */
+declare class ClaudeProvider implements Provider {
+    readonly id = "claude";
+    readonly label = "Claude Code";
+    readonly executable: string;
+    readonly loginCommand = "claude (then /login)";
+    readonly capabilities: ProviderCapabilities;
+    private readonly configDir;
+    private readonly workDir;
+    private readonly appName;
+    constructor(options?: ClaudeProviderOptions);
+    /** Hardened options shared by every completion turn and probe. */
+    private baseOptions;
+    run(req: TurnRequest): AsyncGenerator<TurnEvent, void, undefined>;
+    /** Ask the CLI which models it supports via a short-lived control session. */
+    listModels(): Promise<EngineModel[]>;
+    version(): Promise<string | undefined>;
+    /**
+     * Compare the bundled Agent SDK build against the installed CLI. Their
+     * last version components track the same build number when in sync.
+     */
+    versionSkew(): Promise<VersionSkew | undefined>;
+}
+
+interface AcpHandlers {
+    onUpdate?: (n: SessionNotification) => void;
+    onPermission?: (p: RequestPermissionRequest) => Promise<RequestPermissionResponse>;
+}
+/** A live ACP agent process plus its negotiated connection. */
+interface AcpConnection {
+    agent: ClientSideConnection;
+    init: InitializeResponse;
+    setHandlers(handlers: AcpHandlers): void;
+    close(): void;
+}
+interface AcpProviderOptions {
+    id: string;
+    label: string;
+    /** Executable name or path, resolved like any other CLI. */
+    command: string;
+    args?: string[];
+    /** Explicit executable path override (wins over `command`). */
+    path?: string;
+    env?: Record<string, string>;
+    workDir?: string;
+    appName?: string;
+    /** Id of the session config option that selects the model (default "model"). */
+    modelConfigId?: string;
+    loginCommand?: string;
+    installHint?: string;
+    /** Test seam: replaces process spawning. */
+    connect?: (cwd: string) => Promise<AcpConnection>;
+}
+/**
+ * Any agent speaking the Agent Client Protocol over stdio — OpenCode,
+ * Gemini CLI, Copilot, Cursor, Qwen Code, Kimi, Goose, and anything in the
+ * ACP registry. One adapter, many harnesses.
+ */
+declare class AcpProvider implements Provider {
+    readonly id: string;
+    readonly label: string;
+    readonly executable: string;
+    readonly loginCommand: string;
+    readonly capabilities: ProviderCapabilities;
+    private readonly args;
+    private readonly env;
+    private readonly workDir;
+    private readonly appName;
+    private readonly modelConfigId;
+    private readonly connectImpl;
+    constructor(options: AcpProviderOptions);
+    private spawnConnection;
+    private classify;
+    run(req: TurnRequest): AsyncGenerator<TurnEvent, void, undefined>;
+    private selectModel;
+    listModels(): Promise<EngineModel[]>;
+    /**
+     * The agent's self-reported name/version from the ACP handshake. When the
+     * handshake fails (wrong binary, version too old for ACP), falls back to
+     * `--version` and says so, because that is exactly what `doctor` needs.
+     */
+    version(): Promise<string | undefined>;
+}
+
+interface FindExecutableOptions {
+    /** Explicit path from config/CLI flags; wins when set, errors when wrong. */
+    explicit?: string;
+    /** Extra absolute candidates to try after PATH. */
+    extraPaths?: string[];
+}
+/**
+ * Locate a CLI binary: explicit path first, then PATH, then the usual
+ * install directories. Returns undefined when nothing is found.
+ */
+declare function findExecutable(name: string, options?: FindExecutableOptions): string | undefined;
+/** Like findExecutable, but throws a typed, actionable error when missing. */
+declare function resolveExecutable(providerId: string, name: string, installHint: string, options?: FindExecutableOptions): string;
+/**
+ * Locate the user's installed (and signed-in) Claude Code CLI. The resolved
+ * path is handed to the Agent SDK via `pathToClaudeCodeExecutable`, so the
+ * spawned engine is the same binary — and the same login — the user gets in
+ * their terminal.
+ */
+declare function resolveClaudeExecutable(explicit?: string): string;
+
+declare const VERSION = "0.4.1";
+
+export { type AcpConnection, AcpProvider, type AcpProviderOptions, AgentSession, type AgentSessionOptions, ApiError, AuthRequiredError, ClaudeProvider, type ClaudeProviderOptions, type ClaudeSessionOptions, EngineModel, type Parity, PermissionAdapter, type PermissionAdapterOptions, type PermissionDecision, type PermissionHandler, type PermissionRequest, Provider, ProviderCapabilities, ProviderError, ProviderNotInstalledError, TurnEvent, TurnRequest, VERSION, type VersionSkew, YagamiError, claudeCodeSession, findExecutable, resolveClaudeExecutable, resolveExecutable, settingSourcesFor, startAgentSession, toApiError };

package/dist/index.js

@@ -0,0 +1,259 @@
+import {
+  AcpProvider,
+  ApiError,
+  AsyncQueue,
+  AuthRequiredError,
+  ClaudeProvider,
+  CodexProvider,
+  PROVIDER_PRESETS,
+  ProviderError,
+  ProviderNotInstalledError,
+  SessionCache,
+  VERSION,
+  YagamiEngine,
+  YagamiError,
+  classifyProviderFailure,
+  createProvider,
+  detectProviders,
+  findExecutable,
+  loadProviders,
+  parseModelRef,
+  presetFor,
+  qualifiedModel,
+  resolveClaudeExecutable,
+  resolveExecutable,
+  toApiError
+} from "./chunk-ASS6MJ7C.js";
+
+// src/core/session.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+function claudeCodeSession(prompt, sessionOptions = {}) {
+  const claudePath = resolveClaudeExecutable(
+    sessionOptions.claudePath ?? sessionOptions.options?.pathToClaudeCodeExecutable
+  );
+  return query({
+    prompt,
+    options: {
+      systemPrompt: { type: "preset", preset: "claude_code" },
+      ...sessionOptions.options,
+      pathToClaudeCodeExecutable: claudePath
+    }
+  });
+}
+
+// src/core/agentSession.ts
+import {
+  query as query2
+} from "@anthropic-ai/claude-agent-sdk";
+
+// src/core/parity.ts
+var SETTING_SOURCES = {
+  terminal: ["user", "project", "local"],
+  project: ["project", "local"],
+  isolated: []
+};
+function settingSourcesFor(parity) {
+  return [...SETTING_SOURCES[parity]];
+}
+
+// src/core/permission.ts
+var PermissionAdapter = class {
+  handler;
+  fallback;
+  autoAllow;
+  autoDeny;
+  constructor(options = {}) {
+    this.fallback = options.fallback ?? "deny";
+    this.autoAllow = new Set(options.autoAllow ?? []);
+    this.autoDeny = new Set(options.autoDeny ?? []);
+  }
+  /** Install (or replace) the host decision callback. */
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  allowTool(toolName) {
+    this.autoDeny.delete(toolName);
+    this.autoAllow.add(toolName);
+  }
+  denyTool(toolName) {
+    this.autoAllow.delete(toolName);
+    this.autoDeny.add(toolName);
+  }
+  fallbackResult(reason) {
+    return this.fallback === "allow" ? { behavior: "allow", updatedInput: {} } : { behavior: "deny", message: reason };
+  }
+  /**
+   * The callback to hand to `claudeCodeSession`/the Agent SDK. Typed to
+   * always resolve (never null), and assignable to the SDK's CanUseTool.
+   */
+  canUseTool = async (toolName, input, options) => {
+    if (this.autoDeny.has(toolName)) {
+      return { behavior: "deny", message: `tool "${toolName}" is disabled for this session` };
+    }
+    if (this.autoAllow.has(toolName)) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    if (!this.handler) return this.fallbackResult(`no permission handler is set; denying "${toolName}"`);
+    if (options.signal.aborted) return this.fallbackResult("request aborted");
+    let decision;
+    try {
+      decision = await this.handler({
+        toolName,
+        input,
+        signal: options.signal,
+        ...options.suggestions ? { suggestions: options.suggestions } : {}
+      });
+    } catch (err) {
+      return this.fallbackResult(`permission handler threw: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (decision.behavior === "allow") {
+      return {
+        behavior: "allow",
+        updatedInput: decision.updatedInput ?? input,
+        ...decision.updatedPermissions ? { updatedPermissions: decision.updatedPermissions } : {}
+      };
+    }
+    return {
+      behavior: "deny",
+      message: decision.message ?? `tool "${toolName}" denied by host`,
+      ...decision.interrupt ? { interrupt: true } : {}
+    };
+  };
+};
+
+// src/core/agentSession.ts
+var AgentSession = class {
+  permissions;
+  claudePath;
+  appName;
+  baseOptions;
+  input = new AsyncQueue();
+  query;
+  started = false;
+  closed = false;
+  currentSessionId;
+  constructor(options = {}) {
+    this.claudePath = resolveClaudeExecutable(options.claudePath ?? options.options?.pathToClaudeCodeExecutable);
+    this.appName = options.appName ?? "yagami";
+    this.permissions = new PermissionAdapter(options.permission ?? {});
+    if (options.onPermission) this.permissions.setHandler(options.onPermission);
+    this.baseOptions = {
+      systemPrompt: { type: "preset", preset: "claude_code" },
+      settingSources: settingSourcesFor(options.parity ?? "terminal"),
+      includePartialMessages: true,
+      ...options.cwd ? { cwd: options.cwd } : {},
+      ...options.model ? { model: options.model } : {},
+      ...options.options,
+      canUseTool: options.options?.canUseTool ?? this.permissions.canUseTool,
+      pathToClaudeCodeExecutable: this.claudePath,
+      env: {
+        ...process.env,
+        CLAUDE_AGENT_SDK_CLIENT_APP: `${this.appName}/${VERSION}`,
+        ...options.options?.env
+      }
+    };
+  }
+  /** Set (or clear) the host permission callback after construction. */
+  setPermissionHandler(handler) {
+    this.permissions.setHandler(handler);
+  }
+  /** The live Claude Code session id, once the first turn has started. */
+  get sessionId() {
+    return this.currentSessionId;
+  }
+  /** Queue a user turn. The process starts on the first send and stays warm. */
+  send(text, options = {}) {
+    if (this.closed) throw new Error("session is closed");
+    const content = options.images && options.images.length > 0 ? [
+      ...options.images.map((img) => ({ type: "image", source: { type: "base64", media_type: img.mediaType ?? "image/png", data: img.data } })),
+      { type: "text", text }
+    ] : text;
+    this.input.push({
+      type: "user",
+      message: { role: "user", content },
+      parent_tool_use_id: null,
+      session_id: this.currentSessionId ?? ""
+    });
+    this.ensureStarted();
+  }
+  ensureStarted() {
+    if (this.started) return;
+    this.started = true;
+    this.query = query2({ prompt: this.input, options: this.baseOptions });
+  }
+  /** Iterate every SDK message the agent produces across all turns. */
+  async *[Symbol.asyncIterator]() {
+    this.ensureStarted();
+    try {
+      for await (const msg of this.query) {
+        if (msg.type === "system" && msg.subtype === "init") this.currentSessionId = msg.session_id;
+        else if (msg.type === "result") this.currentSessionId = msg.session_id;
+        yield msg;
+      }
+    } catch (err) {
+      throw classifyProviderFailure("claude", "claude (then /login)", err);
+    }
+  }
+  /** Interrupt the in-flight turn (the CLI's Esc/Ctrl-C). */
+  async interrupt() {
+    await this.query?.interrupt();
+  }
+  /** Switch models mid-session (the CLI's /model). */
+  async setModel(model) {
+    await this.query?.setModel(model);
+  }
+  /** Switch permission mode mid-session (default/acceptEdits/plan/bypassPermissions). */
+  async setPermissionMode(mode) {
+    await this.query?.setPermissionMode(mode);
+  }
+  /** Models the CLI reports as available (for a picker). */
+  async supportedModels() {
+    this.ensureStarted();
+    const models = await this.query.supportedModels();
+    return models.map((m) => ({ value: m.value, displayName: m.displayName }));
+  }
+  /** End the session and tear down the process. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.input.end();
+    this.query?.close();
+  }
+};
+function startAgentSession(prompt, options = {}) {
+  const session = new AgentSession(options);
+  session.send(prompt);
+  return session;
+}
+export {
+  AcpProvider,
+  AgentSession,
+  ApiError,
+  AuthRequiredError,
+  ClaudeProvider,
+  CodexProvider,
+  PROVIDER_PRESETS,
+  PermissionAdapter,
+  ProviderError,
+  ProviderNotInstalledError,
+  SessionCache,
+  VERSION,
+  YagamiEngine,
+  YagamiError,
+  claudeCodeSession,
+  createProvider,
+  detectProviders,
+  findExecutable,
+  loadProviders,
+  parseModelRef,
+  presetFor,
+  qualifiedModel,
+  resolveClaudeExecutable,
+  resolveExecutable,
+  settingSourcesFor,
+  startAgentSession,
+  toApiError
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/session.ts","../src/core/agentSession.ts","../src/core/parity.ts","../src/core/permission.ts"],"sourcesContent":["import {\n  query,\n  type Options,\n  type Query,\n  type SDKUserMessage,\n} from \"@anthropic-ai/claude-agent-sdk\";\nimport { resolveClaudeExecutable } from \"./executable.js\";\n\nexport interface ClaudeSessionOptions {\n  /** Path to the `claude` binary. Auto-resolved when omitted. */\n  claudePath?: string;\n  /** Agent SDK options; merged over yagami's defaults. */\n  options?: Options;\n}\n\n/**\n * Full agentic Claude Code session (tools, permissions, plan mode — the\n * works), backed by the user's installed, signed-in CLI. This is the\n * embeddable \"what T3 Code does\" primitive for building UIs on top of\n * Claude Code: unlike the Messages-API engine, nothing is restricted here.\n *\n * Defaults to the `claude_code` system prompt preset so behavior matches the\n * interactive CLI; pass `options.systemPrompt` to override.\n */\nexport function claudeCodeSession(\n  prompt: string | AsyncIterable<SDKUserMessage>,\n  sessionOptions: ClaudeSessionOptions = {},\n): Query {\n  const claudePath = resolveClaudeExecutable(\n    sessionOptions.claudePath ?? sessionOptions.options?.pathToClaudeCodeExecutable,\n  );\n  return query({\n    prompt,\n    options: {\n      systemPrompt: { type: \"preset\", preset: \"claude_code\" },\n      ...sessionOptions.options,\n      pathToClaudeCodeExecutable: claudePath,\n    },\n  });\n}\n\nexport type {\n  Options as AgentOptions,\n  Query,\n  SDKMessage,\n  SDKUserMessage,\n  PermissionMode,\n  CanUseTool,\n} from \"@anthropic-ai/claude-agent-sdk\";\n","import {\n  query,\n  type Options,\n  type Query,\n  type SDKMessage,\n  type SDKUserMessage,\n} from \"@anthropic-ai/claude-agent-sdk\";\nimport { resolveClaudeExecutable } from \"./executable.js\";\nimport { classifyProviderFailure } from \"./errors.js\";\nimport { settingSourcesFor, type Parity } from \"./parity.js\";\nimport { PermissionAdapter, type PermissionHandler, type PermissionAdapterOptions } from \"./permission.js\";\nimport { AsyncQueue } from \"./providers/queue.js\";\nimport { VERSION } from \"../version.js\";\n\nexport interface AgentSessionOptions {\n  /** Path to the `claude` binary. Auto-resolved when omitted. */\n  claudePath?: string;\n  /** Project directory the agent works in. */\n  cwd?: string;\n  /** How closely to mirror the interactive terminal (default \"terminal\"). */\n  parity?: Parity;\n  /** Model id/alias; the CLI default when omitted. */\n  model?: string;\n  /** Host permission callback (see {@link PermissionAdapter}). */\n  onPermission?: PermissionHandler;\n  /** Options for the permission adapter (fallback, auto-allow/deny). */\n  permission?: PermissionAdapterOptions;\n  /** Reported to the CLI as the client application (e.g. your app name). */\n  appName?: string;\n  /** Extra Agent SDK options, merged last (wins over the above). */\n  options?: Options;\n}\n\n/**\n * A long-lived, agentic Claude Code session for building a UI on top of the\n * CLI — the ruri use case. It keeps one warm process across turns (so only\n * the first turn pays cold-start), threads permission decisions to a host\n * callback, mirrors your terminal settings by default, and exposes the\n * lifecycle the interactive CLI gives you for free: send, interrupt, resume,\n * change model/permission mode, close.\n *\n * Everything the model produces is an {@link SDKMessage} you render yourself.\n */\nexport class AgentSession implements AsyncIterable<SDKMessage> {\n  readonly permissions: PermissionAdapter;\n  private readonly claudePath: string;\n  private readonly appName: string;\n  private readonly baseOptions: Options;\n  private readonly input = new AsyncQueue<SDKUserMessage>();\n  private query: Query | undefined;\n  private started = false;\n  private closed = false;\n  private currentSessionId: string | undefined;\n\n  constructor(options: AgentSessionOptions = {}) {\n    this.claudePath = resolveClaudeExecutable(options.claudePath ?? options.options?.pathToClaudeCodeExecutable);\n    this.appName = options.appName ?? \"yagami\";\n    this.permissions = new PermissionAdapter(options.permission ?? {});\n    if (options.onPermission) this.permissions.setHandler(options.onPermission);\n    this.baseOptions = {\n      systemPrompt: { type: \"preset\", preset: \"claude_code\" },\n      settingSources: settingSourcesFor(options.parity ?? \"terminal\"),\n      includePartialMessages: true,\n      ...(options.cwd ? { cwd: options.cwd } : {}),\n      ...(options.model ? { model: options.model } : {}),\n      ...options.options,\n      canUseTool: options.options?.canUseTool ?? this.permissions.canUseTool,\n      pathToClaudeCodeExecutable: this.claudePath,\n      env: {\n        ...process.env,\n        CLAUDE_AGENT_SDK_CLIENT_APP: `${this.appName}/${VERSION}`,\n        ...options.options?.env,\n      },\n    };\n  }\n\n  /** Set (or clear) the host permission callback after construction. */\n  setPermissionHandler(handler: PermissionHandler | undefined): void {\n    this.permissions.setHandler(handler);\n  }\n\n  /** The live Claude Code session id, once the first turn has started. */\n  get sessionId(): string | undefined {\n    return this.currentSessionId;\n  }\n\n  /** Queue a user turn. The process starts on the first send and stays warm. */\n  send(text: string, options: { images?: Array<{ data: string; mediaType?: string }> } = {}): void {\n    if (this.closed) throw new Error(\"session is closed\");\n    const content =\n      options.images && options.images.length > 0\n        ? [\n            ...options.images.map((img) => ({ type: \"image\" as const, source: { type: \"base64\" as const, media_type: img.mediaType ?? \"image/png\", data: img.data } })),\n            { type: \"text\" as const, text },\n          ]\n        : text;\n    this.input.push({\n      type: \"user\",\n      message: { role: \"user\", content } as SDKUserMessage[\"message\"],\n      parent_tool_use_id: null,\n      session_id: this.currentSessionId ?? \"\",\n    } as SDKUserMessage);\n    this.ensureStarted();\n  }\n\n  private ensureStarted(): void {\n    if (this.started) return;\n    this.started = true;\n    this.query = query({ prompt: this.input, options: this.baseOptions });\n  }\n\n  /** Iterate every SDK message the agent produces across all turns. */\n  async *[Symbol.asyncIterator](): AsyncIterator<SDKMessage> {\n    this.ensureStarted();\n    try {\n      for await (const msg of this.query!) {\n        if (msg.type === \"system\" && msg.subtype === \"init\") this.currentSessionId = msg.session_id;\n        else if (msg.type === \"result\") this.currentSessionId = msg.session_id;\n        yield msg;\n      }\n    } catch (err) {\n      throw classifyProviderFailure(\"claude\", \"claude (then /login)\", err);\n    }\n  }\n\n  /** Interrupt the in-flight turn (the CLI's Esc/Ctrl-C). */\n  async interrupt(): Promise<void> {\n    await this.query?.interrupt();\n  }\n\n  /** Switch models mid-session (the CLI's /model). */\n  async setModel(model: string): Promise<void> {\n    await this.query?.setModel(model);\n  }\n\n  /** Switch permission mode mid-session (default/acceptEdits/plan/bypassPermissions). */\n  async setPermissionMode(mode: \"default\" | \"acceptEdits\" | \"plan\" | \"bypassPermissions\"): Promise<void> {\n    await this.query?.setPermissionMode(mode);\n  }\n\n  /** Models the CLI reports as available (for a picker). */\n  async supportedModels(): Promise<Array<{ value: string; displayName: string }>> {\n    this.ensureStarted();\n    const models = await this.query!.supportedModels();\n    return models.map((m) => ({ value: m.value, displayName: m.displayName }));\n  }\n\n  /** End the session and tear down the process. */\n  close(): void {\n    if (this.closed) return;\n    this.closed = true;\n    this.input.end();\n    this.query?.close();\n  }\n}\n\n/**\n * Convenience: start an {@link AgentSession} and immediately send one turn.\n * Returns the session so callers can iterate it, interrupt, or send more.\n */\nexport function startAgentSession(prompt: string, options: AgentSessionOptions = {}): AgentSession {\n  const session = new AgentSession(options);\n  session.send(prompt);\n  return session;\n}\n","import type { SettingSource } from \"@anthropic-ai/claude-agent-sdk\";\n\n/**\n * How closely an embedded session should mirror the interactive `claude`\n * terminal. This resolves the single most common surprise in library mode:\n * the Agent SDK loads none of your settings by default.\n *\n * - `\"terminal\"` — behave like your CLI: load user + project + local\n *   settings, so CLAUDE.md, skills, hooks, and .mcp.json all apply.\n * - `\"isolated\"` — load nothing (the raw SDK default); the app supplies\n *   everything explicitly. Best when the session must be reproducible or\n *   must not pick up the developer's personal config.\n * - `\"project\"` — load project + local settings but not the user's global\n *   ones: shared repo config without personal CLAUDE.md/skills.\n */\nexport type Parity = \"terminal\" | \"project\" | \"isolated\";\n\nconst SETTING_SOURCES: Record<Parity, SettingSource[]> = {\n  terminal: [\"user\", \"project\", \"local\"],\n  project: [\"project\", \"local\"],\n  isolated: [],\n};\n\n/** The `settingSources` a parity level maps to. */\nexport function settingSourcesFor(parity: Parity): SettingSource[] {\n  return [...SETTING_SOURCES[parity]];\n}\n","import type {\n  CanUseTool,\n  PermissionResult,\n  PermissionUpdate,\n} from \"@anthropic-ai/claude-agent-sdk\";\n\n/** A tool-use request handed to the host for a decision. */\nexport interface PermissionRequest {\n  toolName: string;\n  input: Record<string, unknown>;\n  signal: AbortSignal;\n  /**\n   * Suggested permission updates the host can echo back to stop being asked\n   * again this session (e.g. behind an \"always allow\" button).\n   */\n  suggestions?: PermissionUpdate[];\n}\n\n/**\n * The host's answer. `allow` optionally rewrites the tool input and/or\n * persists permission updates for the rest of the session; `deny` carries a\n * message the model sees and can optionally interrupt the turn.\n */\nexport type PermissionDecision =\n  | { behavior: \"allow\"; updatedInput?: Record<string, unknown>; updatedPermissions?: PermissionUpdate[] }\n  | { behavior: \"deny\"; message?: string; interrupt?: boolean };\n\n/** What the app implements: show UI, return a decision. */\nexport type PermissionHandler = (req: PermissionRequest) => PermissionDecision | Promise<PermissionDecision>;\n\nexport interface PermissionAdapterOptions {\n  /**\n   * Decision used when no handler is set, a handler throws, or the request is\n   * aborted. Defaults to denying — the safe choice for an unattended host.\n   */\n  fallback?: \"allow\" | \"deny\";\n  /** Tool names to auto-allow without ever calling the handler. */\n  autoAllow?: Iterable<string>;\n  /** Tool names to auto-deny without ever calling the handler. */\n  autoDeny?: Iterable<string>;\n}\n\n/**\n * Turns a host-supplied {@link PermissionHandler} into the Agent SDK's\n * {@link CanUseTool} callback, owning the state machine so the app only has\n * to answer one question: allow or deny this tool call?\n *\n * The policy (what to auto-approve) stays with the app — yagami never bakes\n * in a permissive default. Without a handler, everything falls back (deny by\n * default), so a session is safe before the UI is wired up.\n */\nexport class PermissionAdapter {\n  private handler: PermissionHandler | undefined;\n  private readonly fallback: \"allow\" | \"deny\";\n  private readonly autoAllow: Set<string>;\n  private readonly autoDeny: Set<string>;\n\n  constructor(options: PermissionAdapterOptions = {}) {\n    this.fallback = options.fallback ?? \"deny\";\n    this.autoAllow = new Set(options.autoAllow ?? []);\n    this.autoDeny = new Set(options.autoDeny ?? []);\n  }\n\n  /** Install (or replace) the host decision callback. */\n  setHandler(handler: PermissionHandler | undefined): void {\n    this.handler = handler;\n  }\n\n  allowTool(toolName: string): void {\n    this.autoDeny.delete(toolName);\n    this.autoAllow.add(toolName);\n  }\n\n  denyTool(toolName: string): void {\n    this.autoAllow.delete(toolName);\n    this.autoDeny.add(toolName);\n  }\n\n  private fallbackResult(reason: string): PermissionResult {\n    return this.fallback === \"allow\"\n      ? { behavior: \"allow\", updatedInput: {} }\n      : { behavior: \"deny\", message: reason };\n  }\n\n  /**\n   * The callback to hand to `claudeCodeSession`/the Agent SDK. Typed to\n   * always resolve (never null), and assignable to the SDK's CanUseTool.\n   */\n  readonly canUseTool: (\n    ...args: Parameters<CanUseTool>\n  ) => Promise<PermissionResult> = async (toolName, input, options) => {\n    if (this.autoDeny.has(toolName)) {\n      return { behavior: \"deny\", message: `tool \"${toolName}\" is disabled for this session` };\n    }\n    if (this.autoAllow.has(toolName)) {\n      return { behavior: \"allow\", updatedInput: input };\n    }\n    if (!this.handler) return this.fallbackResult(`no permission handler is set; denying \"${toolName}\"`);\n    if (options.signal.aborted) return this.fallbackResult(\"request aborted\");\n\n    let decision: PermissionDecision;\n    try {\n      decision = await this.handler({\n        toolName,\n        input,\n        signal: options.signal,\n        ...(options.suggestions ? { suggestions: options.suggestions } : {}),\n      });\n    } catch (err) {\n      return this.fallbackResult(`permission handler threw: ${err instanceof Error ? err.message : String(err)}`);\n    }\n\n    if (decision.behavior === \"allow\") {\n      return {\n        behavior: \"allow\",\n        updatedInput: decision.updatedInput ?? input,\n        ...(decision.updatedPermissions ? { updatedPermissions: decision.updatedPermissions } : {}),\n      };\n    }\n    return {\n      behavior: \"deny\",\n      message: decision.message ?? `tool \"${toolName}\" denied by host`,\n      ...(decision.interrupt ? { interrupt: true } : {}),\n    };\n  };\n}\n"],"mappings":"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","names":["query","query"]}