anycodex 0.0.1 → 0.0.2

package/dist/chunk-TDYQG5PB.js

@@ -0,0 +1,1621 @@
+#!/usr/bin/env node
+import {
+  MessageID,
+  PartID,
+  SessionID
+} from "./chunk-ZXPWUU3S.js";
+import {
+  Log,
+  NamedError,
+  NotFoundError,
+  ProjectID,
+  join
+} from "./chunk-6DDCZPRP.js";
+import {
+  withStatics
+} from "./chunk-KB4MYP36.js";
+
+// ../agent/dist/chunk-FSDC4TEW.js
+import { EventEmitter as EventEmitter2 } from "events";
+import z6 from "zod";
+import z from "zod";
+import { Decimal } from "decimal.js";
+import z5 from "zod";
+import { EventEmitter } from "events";
+import z4 from "zod";
+import { APICallError, convertToModelMessages, LoadAPIKeyError } from "ai";
+import z2 from "zod";
+import { STATUS_CODES } from "http";
+import { Schema } from "effect";
+import z3 from "zod";
+var Slug;
+((Slug2) => {
+  const ADJECTIVES = [
+    "brave",
+    "calm",
+    "clever",
+    "cosmic",
+    "crisp",
+    "curious",
+    "eager",
+    "gentle",
+    "glowing",
+    "happy",
+    "hidden",
+    "jolly",
+    "kind",
+    "lucky",
+    "mighty",
+    "misty",
+    "neon",
+    "nimble",
+    "playful",
+    "proud",
+    "quick",
+    "quiet",
+    "shiny",
+    "silent",
+    "stellar",
+    "sunny",
+    "swift",
+    "tidy",
+    "witty"
+  ];
+  const NOUNS = [
+    "cabin",
+    "cactus",
+    "canyon",
+    "circuit",
+    "comet",
+    "eagle",
+    "engine",
+    "falcon",
+    "forest",
+    "garden",
+    "harbor",
+    "island",
+    "knight",
+    "lagoon",
+    "meadow",
+    "moon",
+    "mountain",
+    "nebula",
+    "orchid",
+    "otter",
+    "panda",
+    "pixel",
+    "planet",
+    "river",
+    "rocket",
+    "sailor",
+    "squid",
+    "star",
+    "tiger",
+    "wizard",
+    "wolf"
+  ];
+  function create() {
+    return [
+      ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)],
+      NOUNS[Math.floor(Math.random() * NOUNS.length)]
+    ].join("-");
+  }
+  Slug2.create = create;
+})(Slug || (Slug = {}));
+var Installation;
+((Installation2) => {
+  Installation2.VERSION = typeof OPENCODE_VERSION === "string" ? OPENCODE_VERSION : "local";
+  Installation2.CHANNEL = typeof OPENCODE_CHANNEL === "string" ? OPENCODE_CHANNEL : "local";
+  Installation2.USER_AGENT = `claude-cli/2.1.77`;
+  function isPreview() {
+    return Installation2.CHANNEL !== "latest";
+  }
+  Installation2.isPreview = isPreview;
+  function isLocal() {
+    return Installation2.CHANNEL === "local";
+  }
+  Installation2.isLocal = isLocal;
+  Installation2.Info = z.object({
+    version: z.string(),
+    latest: z.string()
+  }).meta({ ref: "InstallationInfo" });
+})(Installation || (Installation = {}));
+var LSP;
+((LSP2) => {
+  LSP2.Range = z2.object({
+    start: z2.object({
+      line: z2.number(),
+      character: z2.number()
+    }),
+    end: z2.object({
+      line: z2.number(),
+      character: z2.number()
+    })
+  }).meta({ ref: "LSPRange" });
+  LSP2.Diagnostic = {
+    pretty(d) {
+      return `${d.range.start.line}:${d.range.start.character} ${d.severity === 1 ? "error" : "warning"}: ${d.message}`;
+    }
+  };
+  async function init() {
+  }
+  LSP2.init = init;
+  async function touchFile(_filepath, _wait) {
+  }
+  LSP2.touchFile = touchFile;
+  async function diagnostics() {
+    return /* @__PURE__ */ new Map();
+  }
+  LSP2.diagnostics = diagnostics;
+  async function hasClients(_file) {
+    return false;
+  }
+  LSP2.hasClients = hasClients;
+  async function definition(_position) {
+    return [];
+  }
+  LSP2.definition = definition;
+  async function references(_position) {
+    return [];
+  }
+  LSP2.references = references;
+  async function hover(_position) {
+    return null;
+  }
+  LSP2.hover = hover;
+  async function documentSymbol(_uri) {
+    return [];
+  }
+  LSP2.documentSymbol = documentSymbol;
+  async function workspaceSymbol(_query) {
+    return [];
+  }
+  LSP2.workspaceSymbol = workspaceSymbol;
+  async function implementation(_position) {
+    return [];
+  }
+  LSP2.implementation = implementation;
+  async function prepareCallHierarchy(_position) {
+    return [];
+  }
+  LSP2.prepareCallHierarchy = prepareCallHierarchy;
+  async function incomingCalls(_position) {
+    return [];
+  }
+  LSP2.incomingCalls = incomingCalls;
+  async function outgoingCalls(_position) {
+    return [];
+  }
+  LSP2.outgoingCalls = outgoingCalls;
+})(LSP || (LSP = {}));
+function fn(schema, cb) {
+  const result = (input) => {
+    const parsed = schema.parse(input);
+    return cb(parsed);
+  };
+  result.force = (input) => cb(input);
+  result.schema = schema;
+  return result;
+}
+function iife(fn2) {
+  return fn2();
+}
+function defer(fn2) {
+  return {
+    [Symbol.dispose]() {
+      fn2();
+    },
+    [Symbol.asyncDispose]() {
+      return Promise.resolve(fn2());
+    }
+  };
+}
+var Token;
+((Token2) => {
+  const CHARS_PER_TOKEN = 4;
+  function estimate(input) {
+    return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN));
+  }
+  Token2.estimate = estimate;
+})(Token || (Token = {}));
+var ProviderError;
+((ProviderError2) => {
+  const OVERFLOW_PATTERNS = [
+    /prompt is too long/i,
+    // Anthropic
+    /input is too long for requested model/i,
+    // Amazon Bedrock
+    /exceeds the context window/i,
+    // OpenAI (Completions + Responses API message text)
+    /input token count.*exceeds the maximum/i,
+    // Google (Gemini)
+    /maximum prompt length is \d+/i,
+    // xAI (Grok)
+    /reduce the length of the messages/i,
+    // Groq
+    /maximum context length is \d+ tokens/i,
+    // OpenRouter, DeepSeek
+    /exceeds the limit of \d+/i,
+    // GitHub Copilot
+    /exceeds the available context size/i,
+    // llama.cpp server
+    /greater than the context length/i,
+    // LM Studio
+    /context window exceeds limit/i,
+    // MiniMax
+    /exceeded model token limit/i,
+    // Kimi For Coding, Moonshot
+    /context[_ ]length[_ ]exceeded/i,
+    // Generic fallback
+    /request entity too large/i
+    // HTTP 413
+  ];
+  function isOpenAiErrorRetryable(e) {
+    const status = e.statusCode;
+    if (!status) return e.isRetryable;
+    return status === 404 || e.isRetryable;
+  }
+  function isOverflow(message2) {
+    if (OVERFLOW_PATTERNS.some((p) => p.test(message2))) return true;
+    return /^4(00|13)\s*(status code)?\s*\(no body\)/i.test(message2);
+  }
+  function message(providerID, e) {
+    return iife(() => {
+      const msg = e.message;
+      if (msg === "") {
+        if (e.responseBody) return e.responseBody;
+        if (e.statusCode) {
+          const err = STATUS_CODES[e.statusCode];
+          if (err) return err;
+        }
+        return "Unknown error";
+      }
+      if (!e.responseBody || e.statusCode && msg !== STATUS_CODES[e.statusCode]) {
+        return msg;
+      }
+      try {
+        const body = JSON.parse(e.responseBody);
+        const errMsg = body.message || body.error || body.error?.message;
+        if (errMsg && typeof errMsg === "string") {
+          return `${msg}: ${errMsg}`;
+        }
+      } catch {
+      }
+      if (/^\s*<!doctype|^\s*<html/i.test(e.responseBody)) {
+        if (e.statusCode === 401) {
+          return "Unauthorized: request was blocked by a gateway or proxy. Your authentication token may be missing or expired \u2014 try running `opencode auth login <your provider URL>` to re-authenticate.";
+        }
+        if (e.statusCode === 403) {
+          return "Forbidden: request was blocked by a gateway or proxy. You may not have permission to access this resource \u2014 check your account and provider settings.";
+        }
+        return msg;
+      }
+      return `${msg}: ${e.responseBody}`;
+    }).trim();
+  }
+  function json(input) {
+    if (typeof input === "string") {
+      try {
+        const result = JSON.parse(input);
+        if (result && typeof result === "object") return result;
+        return void 0;
+      } catch {
+        return void 0;
+      }
+    }
+    if (typeof input === "object" && input !== null) {
+      return input;
+    }
+    return void 0;
+  }
+  function parseStreamError(input) {
+    const body = json(input);
+    if (!body) return;
+    const responseBody = JSON.stringify(body);
+    if (body.type !== "error") return;
+    switch (body?.error?.code) {
+      case "context_length_exceeded":
+        return {
+          type: "context_overflow",
+          message: "Input exceeds context window of this model",
+          responseBody
+        };
+      case "insufficient_quota":
+        return {
+          type: "api_error",
+          message: "Quota exceeded. Check your plan and billing details.",
+          isRetryable: false,
+          responseBody
+        };
+      case "usage_not_included":
+        return {
+          type: "api_error",
+          message: "To use Codex with your ChatGPT plan, upgrade to Plus: https://chatgpt.com/explore/plus.",
+          isRetryable: false,
+          responseBody
+        };
+      case "invalid_prompt":
+        return {
+          type: "api_error",
+          message: typeof body?.error?.message === "string" ? body?.error?.message : "Invalid prompt.",
+          isRetryable: false,
+          responseBody
+        };
+    }
+  }
+  ProviderError2.parseStreamError = parseStreamError;
+  function parseAPICallError(input) {
+    const m = message(input.providerID, input.error);
+    if (isOverflow(m) || input.error.statusCode === 413) {
+      return {
+        type: "context_overflow",
+        message: m,
+        responseBody: input.error.responseBody
+      };
+    }
+    const metadata = input.error.url ? { url: input.error.url } : void 0;
+    return {
+      type: "api_error",
+      message: m,
+      statusCode: input.error.statusCode,
+      isRetryable: input.providerID.startsWith("openai") ? isOpenAiErrorRetryable(input.error) : input.error.isRetryable,
+      responseHeaders: input.error.responseHeaders,
+      responseBody: input.error.responseBody,
+      metadata
+    };
+  }
+  ProviderError2.parseAPICallError = parseAPICallError;
+})(ProviderError || (ProviderError = {}));
+var providerIdSchema = Schema.String.pipe(Schema.brand("ProviderID"));
+var ProviderID = providerIdSchema.pipe(
+  withStatics((schema) => ({
+    make: (id) => schema.makeUnsafe(id),
+    zod: z3.string().pipe(z3.custom()),
+    // Well-known providers
+    opencode: schema.makeUnsafe("opencode"),
+    anthropic: schema.makeUnsafe("anthropic"),
+    openai: schema.makeUnsafe("openai"),
+    google: schema.makeUnsafe("google"),
+    googleVertex: schema.makeUnsafe("google-vertex"),
+    githubCopilot: schema.makeUnsafe("github-copilot"),
+    githubCopilotEnterprise: schema.makeUnsafe("github-copilot-enterprise"),
+    amazonBedrock: schema.makeUnsafe("amazon-bedrock"),
+    azure: schema.makeUnsafe("azure"),
+    openrouter: schema.makeUnsafe("openrouter"),
+    mistral: schema.makeUnsafe("mistral")
+  }))
+);
+var modelIdSchema = Schema.String.pipe(Schema.brand("ModelID"));
+var ModelID = modelIdSchema.pipe(
+  withStatics((schema) => ({
+    make: (id) => schema.makeUnsafe(id),
+    zod: z3.string().pipe(z3.custom())
+  }))
+);
+var MessageV2;
+((MessageV22) => {
+  function isMedia(mime) {
+    return mime.startsWith("image/") || mime === "application/pdf";
+  }
+  MessageV22.isMedia = isMedia;
+  MessageV22.OutputLengthError = NamedError.create("MessageOutputLengthError", z4.object({}));
+  MessageV22.AbortedError = NamedError.create("MessageAbortedError", z4.object({ message: z4.string() }));
+  MessageV22.StructuredOutputError = NamedError.create(
+    "StructuredOutputError",
+    z4.object({
+      message: z4.string(),
+      retries: z4.number()
+    })
+  );
+  MessageV22.AuthError = NamedError.create(
+    "ProviderAuthError",
+    z4.object({
+      providerID: z4.string(),
+      message: z4.string()
+    })
+  );
+  MessageV22.APIError = NamedError.create(
+    "APIError",
+    z4.object({
+      message: z4.string(),
+      statusCode: z4.number().optional(),
+      isRetryable: z4.boolean(),
+      responseHeaders: z4.record(z4.string(), z4.string()).optional(),
+      responseBody: z4.string().optional(),
+      metadata: z4.record(z4.string(), z4.string()).optional()
+    })
+  );
+  MessageV22.ContextOverflowError = NamedError.create(
+    "ContextOverflowError",
+    z4.object({ message: z4.string(), responseBody: z4.string().optional() })
+  );
+  MessageV22.OutputFormatText = z4.object({
+    type: z4.literal("text")
+  }).meta({
+    ref: "OutputFormatText"
+  });
+  MessageV22.OutputFormatJsonSchema = z4.object({
+    type: z4.literal("json_schema"),
+    schema: z4.record(z4.string(), z4.any()).meta({ ref: "JSONSchema" }),
+    retryCount: z4.number().int().min(0).default(2)
+  }).meta({
+    ref: "OutputFormatJsonSchema"
+  });
+  MessageV22.Format = z4.discriminatedUnion("type", [MessageV22.OutputFormatText, MessageV22.OutputFormatJsonSchema]).meta({
+    ref: "OutputFormat"
+  });
+  const PartBase = z4.object({
+    id: PartID.zod,
+    sessionID: SessionID.zod,
+    messageID: MessageID.zod
+  });
+  MessageV22.FileDiff = z4.object({
+    file: z4.string(),
+    before: z4.string(),
+    after: z4.string(),
+    additions: z4.number(),
+    deletions: z4.number(),
+    status: z4.enum(["added", "deleted", "modified"]).optional()
+  }).meta({
+    ref: "FileDiff"
+  });
+  MessageV22.PatchPart = PartBase.extend({
+    type: z4.literal("patch"),
+    hash: z4.string(),
+    files: z4.string().array()
+  }).meta({
+    ref: "PatchPart"
+  });
+  MessageV22.TextPart = PartBase.extend({
+    type: z4.literal("text"),
+    text: z4.string(),
+    synthetic: z4.boolean().optional(),
+    ignored: z4.boolean().optional(),
+    time: z4.object({
+      start: z4.number(),
+      end: z4.number().optional()
+    }).optional(),
+    metadata: z4.record(z4.string(), z4.any()).optional()
+  }).meta({
+    ref: "TextPart"
+  });
+  MessageV22.ReasoningPart = PartBase.extend({
+    type: z4.literal("reasoning"),
+    text: z4.string(),
+    metadata: z4.record(z4.string(), z4.any()).optional(),
+    time: z4.object({
+      start: z4.number(),
+      end: z4.number().optional()
+    })
+  }).meta({
+    ref: "ReasoningPart"
+  });
+  const FilePartSourceBase = z4.object({
+    text: z4.object({
+      value: z4.string(),
+      start: z4.number().int(),
+      end: z4.number().int()
+    }).meta({
+      ref: "FilePartSourceText"
+    })
+  });
+  MessageV22.FileSource = FilePartSourceBase.extend({
+    type: z4.literal("file"),
+    path: z4.string()
+  }).meta({
+    ref: "FileSource"
+  });
+  MessageV22.SymbolSource = FilePartSourceBase.extend({
+    type: z4.literal("symbol"),
+    path: z4.string(),
+    range: LSP.Range,
+    name: z4.string(),
+    kind: z4.number().int()
+  }).meta({
+    ref: "SymbolSource"
+  });
+  MessageV22.ResourceSource = FilePartSourceBase.extend({
+    type: z4.literal("resource"),
+    clientName: z4.string(),
+    uri: z4.string()
+  }).meta({
+    ref: "ResourceSource"
+  });
+  MessageV22.FilePartSource = z4.discriminatedUnion("type", [MessageV22.FileSource, MessageV22.SymbolSource, MessageV22.ResourceSource]).meta({
+    ref: "FilePartSource"
+  });
+  MessageV22.FilePart = PartBase.extend({
+    type: z4.literal("file"),
+    mime: z4.string(),
+    filename: z4.string().optional(),
+    url: z4.string(),
+    source: MessageV22.FilePartSource.optional()
+  }).meta({
+    ref: "FilePart"
+  });
+  MessageV22.AgentPart = PartBase.extend({
+    type: z4.literal("agent"),
+    name: z4.string(),
+    source: z4.object({
+      value: z4.string(),
+      start: z4.number().int(),
+      end: z4.number().int()
+    }).optional()
+  }).meta({
+    ref: "AgentPart"
+  });
+  MessageV22.CompactionPart = PartBase.extend({
+    type: z4.literal("compaction"),
+    auto: z4.boolean(),
+    overflow: z4.boolean().optional()
+  }).meta({
+    ref: "CompactionPart"
+  });
+  MessageV22.SubtaskPart = PartBase.extend({
+    type: z4.literal("subtask"),
+    prompt: z4.string(),
+    description: z4.string(),
+    agent: z4.string(),
+    model: z4.object({
+      providerID: ProviderID.zod,
+      modelID: ModelID.zod
+    }).optional(),
+    command: z4.string().optional()
+  }).meta({
+    ref: "SubtaskPart"
+  });
+  MessageV22.RetryPart = PartBase.extend({
+    type: z4.literal("retry"),
+    attempt: z4.number(),
+    error: MessageV22.APIError.Schema,
+    time: z4.object({
+      created: z4.number()
+    })
+  }).meta({
+    ref: "RetryPart"
+  });
+  MessageV22.StepStartPart = PartBase.extend({
+    type: z4.literal("step-start")
+  }).meta({
+    ref: "StepStartPart"
+  });
+  MessageV22.StepFinishPart = PartBase.extend({
+    type: z4.literal("step-finish"),
+    reason: z4.string(),
+    cost: z4.number(),
+    tokens: z4.object({
+      total: z4.number().optional(),
+      input: z4.number(),
+      output: z4.number(),
+      reasoning: z4.number(),
+      cache: z4.object({
+        read: z4.number(),
+        write: z4.number()
+      })
+    })
+  }).meta({
+    ref: "StepFinishPart"
+  });
+  MessageV22.ToolStatePending = z4.object({
+    status: z4.literal("pending"),
+    input: z4.record(z4.string(), z4.any()),
+    raw: z4.string()
+  }).meta({
+    ref: "ToolStatePending"
+  });
+  MessageV22.ToolStateRunning = z4.object({
+    status: z4.literal("running"),
+    input: z4.record(z4.string(), z4.any()),
+    title: z4.string().optional(),
+    metadata: z4.record(z4.string(), z4.any()).optional(),
+    time: z4.object({
+      start: z4.number()
+    })
+  }).meta({
+    ref: "ToolStateRunning"
+  });
+  MessageV22.ToolStateCompleted = z4.object({
+    status: z4.literal("completed"),
+    input: z4.record(z4.string(), z4.any()),
+    output: z4.string(),
+    title: z4.string(),
+    metadata: z4.record(z4.string(), z4.any()),
+    time: z4.object({
+      start: z4.number(),
+      end: z4.number(),
+      compacted: z4.number().optional()
+    }),
+    attachments: MessageV22.FilePart.array().optional()
+  }).meta({
+    ref: "ToolStateCompleted"
+  });
+  MessageV22.ToolStateError = z4.object({
+    status: z4.literal("error"),
+    input: z4.record(z4.string(), z4.any()),
+    error: z4.string(),
+    metadata: z4.record(z4.string(), z4.any()).optional(),
+    time: z4.object({
+      start: z4.number(),
+      end: z4.number()
+    })
+  }).meta({
+    ref: "ToolStateError"
+  });
+  MessageV22.ToolState = z4.discriminatedUnion("status", [MessageV22.ToolStatePending, MessageV22.ToolStateRunning, MessageV22.ToolStateCompleted, MessageV22.ToolStateError]).meta({
+    ref: "ToolState"
+  });
+  MessageV22.ToolPart = PartBase.extend({
+    type: z4.literal("tool"),
+    callID: z4.string(),
+    tool: z4.string(),
+    state: MessageV22.ToolState,
+    metadata: z4.record(z4.string(), z4.any()).optional()
+  }).meta({
+    ref: "ToolPart"
+  });
+  const Base = z4.object({
+    id: MessageID.zod,
+    sessionID: SessionID.zod
+  });
+  MessageV22.User = Base.extend({
+    role: z4.literal("user"),
+    time: z4.object({
+      created: z4.number()
+    }),
+    format: MessageV22.Format.optional(),
+    summary: z4.object({
+      title: z4.string().optional(),
+      body: z4.string().optional(),
+      diffs: MessageV22.FileDiff.array()
+    }).optional(),
+    agent: z4.string(),
+    model: z4.object({
+      providerID: ProviderID.zod,
+      modelID: ModelID.zod
+    }),
+    system: z4.string().optional(),
+    tools: z4.record(z4.string(), z4.boolean()).optional(),
+    variant: z4.string().optional()
+  }).meta({
+    ref: "UserMessage"
+  });
+  MessageV22.Part = z4.discriminatedUnion("type", [
+    MessageV22.TextPart,
+    MessageV22.SubtaskPart,
+    MessageV22.ReasoningPart,
+    MessageV22.FilePart,
+    MessageV22.ToolPart,
+    MessageV22.StepStartPart,
+    MessageV22.StepFinishPart,
+    MessageV22.PatchPart,
+    MessageV22.AgentPart,
+    MessageV22.RetryPart,
+    MessageV22.CompactionPart
+  ]).meta({
+    ref: "Part"
+  });
+  MessageV22.Assistant = Base.extend({
+    role: z4.literal("assistant"),
+    time: z4.object({
+      created: z4.number(),
+      completed: z4.number().optional()
+    }),
+    error: z4.discriminatedUnion("name", [
+      MessageV22.AuthError.Schema,
+      NamedError.Unknown.Schema,
+      MessageV22.OutputLengthError.Schema,
+      MessageV22.AbortedError.Schema,
+      MessageV22.StructuredOutputError.Schema,
+      MessageV22.ContextOverflowError.Schema,
+      MessageV22.APIError.Schema
+    ]).optional(),
+    parentID: MessageID.zod,
+    modelID: ModelID.zod,
+    providerID: ProviderID.zod,
+    /**
+     * @deprecated
+     */
+    mode: z4.string(),
+    agent: z4.string(),
+    path: z4.object({
+      cwd: z4.string(),
+      root: z4.string()
+    }),
+    summary: z4.boolean().optional(),
+    cost: z4.number(),
+    tokens: z4.object({
+      total: z4.number().optional(),
+      input: z4.number(),
+      output: z4.number(),
+      reasoning: z4.number(),
+      cache: z4.object({
+        read: z4.number(),
+        write: z4.number()
+      })
+    }),
+    structured: z4.any().optional(),
+    variant: z4.string().optional(),
+    finish: z4.string().optional()
+  }).meta({
+    ref: "AssistantMessage"
+  });
+  MessageV22.Info = z4.discriminatedUnion("role", [MessageV22.User, MessageV22.Assistant]).meta({
+    ref: "Message"
+  });
+  MessageV22.WithParts = z4.object({
+    info: MessageV22.Info,
+    parts: z4.array(MessageV22.Part)
+  });
+  const Cursor = z4.object({
+    id: MessageID.zod,
+    time: z4.number()
+  });
+  MessageV22.cursor = {
+    encode(input) {
+      return Buffer.from(JSON.stringify(input)).toString("base64url");
+    },
+    decode(input) {
+      return Cursor.parse(JSON.parse(Buffer.from(input, "base64url").toString("utf8")));
+    }
+  };
+  const info = (row) => ({
+    ...row.data,
+    id: row.id,
+    sessionID: row.session_id
+  });
+  const part = (row) => ({
+    ...row.data,
+    id: row.id,
+    sessionID: row.session_id,
+    messageID: row.message_id
+  });
+  const olderFilter = (cursor2) => ({
+    op: "or",
+    conditions: [
+      { op: "lt", field: "time_created", value: cursor2.time },
+      { op: "and", conditions: [
+        { op: "eq", field: "time_created", value: cursor2.time },
+        { op: "lt", field: "id", value: cursor2.id }
+      ] }
+    ]
+  });
+  async function hydrate(context, rows) {
+    const ids = rows.map((row) => row.id);
+    const partByMessage = /* @__PURE__ */ new Map();
+    if (ids.length > 0) {
+      const partRows = context.db.findMany("part", {
+        filter: { op: "in", field: "message_id", values: ids },
+        orderBy: [{ field: "message_id", direction: "asc" }, { field: "id", direction: "asc" }]
+      });
+      for (const row of partRows) {
+        const next = part(row);
+        const list = partByMessage.get(row.message_id);
+        if (list) list.push(next);
+        else partByMessage.set(row.message_id, [next]);
+      }
+    }
+    return rows.map((row) => ({
+      info: info(row),
+      parts: partByMessage.get(row.id) ?? []
+    }));
+  }
+  function toModelMessages(input, model, options) {
+    const result = [];
+    const toolNames = /* @__PURE__ */ new Set();
+    const supportsMediaInToolResults = (() => {
+      if (model.api.npm === "@ai-sdk/anthropic") return true;
+      if (model.api.npm === "@ai-sdk/openai") return true;
+      if (model.api.npm === "@ai-sdk/amazon-bedrock") return true;
+      if (model.api.npm === "@ai-sdk/google-vertex/anthropic") return true;
+      if (model.api.npm === "@ai-sdk/google") {
+        const id = model.api.id.toLowerCase();
+        return id.includes("gemini-3") && !id.includes("gemini-2");
+      }
+      return false;
+    })();
+    const toModelOutput = (output) => {
+      if (typeof output === "string") {
+        return { type: "text", value: output };
+      }
+      if (typeof output === "object") {
+        const outputObject = output;
+        const attachments = (outputObject.attachments ?? []).filter((attachment) => {
+          return attachment.url.startsWith("data:") && attachment.url.includes(",");
+        });
+        return {
+          type: "content",
+          value: [
+            { type: "text", text: outputObject.text },
+            ...attachments.map((attachment) => ({
+              type: "media",
+              mediaType: attachment.mime,
+              data: iife(() => {
+                const commaIndex = attachment.url.indexOf(",");
+                return commaIndex === -1 ? attachment.url : attachment.url.slice(commaIndex + 1);
+              })
+            }))
+          ]
+        };
+      }
+      return { type: "json", value: output };
+    };
+    for (const msg of input) {
+      if (msg.parts.length === 0) continue;
+      if (msg.info.role === "user") {
+        const userMessage = {
+          id: msg.info.id,
+          role: "user",
+          parts: []
+        };
+        result.push(userMessage);
+        for (const part2 of msg.parts) {
+          if (part2.type === "text" && !part2.ignored)
+            userMessage.parts.push({
+              type: "text",
+              text: part2.text
+            });
+          if (part2.type === "file" && part2.mime !== "text/plain" && part2.mime !== "application/x-directory") {
+            if (options?.stripMedia && isMedia(part2.mime)) {
+              userMessage.parts.push({
+                type: "text",
+                text: `[Attached ${part2.mime}: ${part2.filename ?? "file"}]`
+              });
+            } else {
+              userMessage.parts.push({
+                type: "file",
+                url: part2.url,
+                mediaType: part2.mime,
+                filename: part2.filename
+              });
+            }
+          }
+          if (part2.type === "compaction") {
+            userMessage.parts.push({
+              type: "text",
+              text: "What did we do so far?"
+            });
+          }
+          if (part2.type === "subtask") {
+            userMessage.parts.push({
+              type: "text",
+              text: "The following tool was executed by the user"
+            });
+          }
+        }
+      }
+      if (msg.info.role === "assistant") {
+        const differentModel = `${model.providerID}/${model.id}` !== `${msg.info.providerID}/${msg.info.modelID}`;
+        const media = [];
+        if (msg.info.error && !(MessageV22.AbortedError.isInstance(msg.info.error) && msg.parts.some((part2) => part2.type !== "step-start" && part2.type !== "reasoning"))) {
+          continue;
+        }
+        const assistantMessage = {
+          id: msg.info.id,
+          role: "assistant",
+          parts: []
+        };
+        for (const part2 of msg.parts) {
+          if (part2.type === "text")
+            assistantMessage.parts.push({
+              type: "text",
+              text: part2.text,
+              ...differentModel ? {} : { providerMetadata: part2.metadata }
+            });
+          if (part2.type === "step-start")
+            assistantMessage.parts.push({
+              type: "step-start"
+            });
+          if (part2.type === "tool") {
+            toolNames.add(part2.tool);
+            if (part2.state.status === "completed") {
+              const outputText = part2.state.time.compacted ? "[Old tool result content cleared]" : part2.state.output;
+              const attachments = part2.state.time.compacted || options?.stripMedia ? [] : part2.state.attachments ?? [];
+              const mediaAttachments = attachments.filter((a) => isMedia(a.mime));
+              const nonMediaAttachments = attachments.filter((a) => !isMedia(a.mime));
+              if (!supportsMediaInToolResults && mediaAttachments.length > 0) {
+                media.push(...mediaAttachments);
+              }
+              const finalAttachments = supportsMediaInToolResults ? attachments : nonMediaAttachments;
+              const output = finalAttachments.length > 0 ? {
+                text: outputText,
+                attachments: finalAttachments
+              } : outputText;
+              assistantMessage.parts.push({
+                type: "tool-" + part2.tool,
+                state: "output-available",
+                toolCallId: part2.callID,
+                input: part2.state.input,
+                output,
+                ...differentModel ? {} : { callProviderMetadata: part2.metadata }
+              });
+            }
+            if (part2.state.status === "error")
+              assistantMessage.parts.push({
+                type: "tool-" + part2.tool,
+                state: "output-error",
+                toolCallId: part2.callID,
+                input: part2.state.input,
+                errorText: part2.state.error,
+                ...differentModel ? {} : { callProviderMetadata: part2.metadata }
+              });
+            if (part2.state.status === "pending" || part2.state.status === "running")
+              assistantMessage.parts.push({
+                type: "tool-" + part2.tool,
+                state: "output-error",
+                toolCallId: part2.callID,
+                input: part2.state.input,
+                errorText: "[Tool execution was interrupted]",
+                ...differentModel ? {} : { callProviderMetadata: part2.metadata }
+              });
+          }
+          if (part2.type === "reasoning") {
+            assistantMessage.parts.push({
+              type: "reasoning",
+              text: part2.text,
+              ...differentModel ? {} : { providerMetadata: part2.metadata }
+            });
+          }
+        }
+        if (assistantMessage.parts.length > 0) {
+          result.push(assistantMessage);
+          if (media.length > 0) {
+            result.push({
+              id: MessageID.ascending(),
+              role: "user",
+              parts: [
+                {
+                  type: "text",
+                  text: "Attached image(s) from tool result:"
+                },
+                ...media.map((attachment) => ({
+                  type: "file",
+                  url: attachment.url,
+                  mediaType: attachment.mime
+                }))
+              ]
+            });
+          }
+        }
+      }
+    }
+    const tools = Object.fromEntries(Array.from(toolNames).map((toolName) => [toolName, { toModelOutput }]));
+    return convertToModelMessages(
+      result.filter((msg) => msg.parts.some((part2) => part2.type !== "step-start")),
+      {
+        //@ts-expect-error (convertToModelMessages expects a ToolSet but only actually needs tools[name]?.toModelOutput)
+        tools
+      }
+    );
+  }
+  MessageV22.toModelMessages = toModelMessages;
+  async function page(context, input) {
+    const before = input.before ? MessageV22.cursor.decode(input.before) : void 0;
+    const conditions = [{ op: "eq", field: "session_id", value: input.sessionID }];
+    if (before) conditions.push(olderFilter(before));
+    const rows = context.db.findMany("message", {
+      filter: { op: "and", conditions },
+      orderBy: [{ field: "time_created", direction: "desc" }, { field: "id", direction: "desc" }],
+      limit: input.limit + 1
+    });
+    if (rows.length === 0) {
+      const row = context.db.findOne("session", { op: "eq", field: "id", value: input.sessionID });
+      if (!row) throw new NotFoundError({ message: `Session not found: ${input.sessionID}` });
+      return {
+        items: [],
+        more: false
+      };
+    }
+    const more = rows.length > input.limit;
+    const pg = more ? rows.slice(0, input.limit) : rows;
+    const items = await hydrate(context, pg);
+    items.reverse();
+    const tail = pg.at(-1);
+    return {
+      items,
+      more,
+      cursor: more && tail ? MessageV22.cursor.encode({ id: tail.id, time: tail.time_created }) : void 0
+    };
+  }
+  MessageV22.page = page;
+  async function* stream(context, sessionID) {
+    const size = 50;
+    let before;
+    while (true) {
+      const next = await page(context, { sessionID, limit: size, before });
+      if (next.items.length === 0) break;
+      for (let i = next.items.length - 1; i >= 0; i--) {
+        yield next.items[i];
+      }
+      if (!next.more || !next.cursor) break;
+      before = next.cursor;
+    }
+  }
+  MessageV22.stream = stream;
+  async function parts(context, message_id) {
+    const rows = context.db.findMany("part", {
+      filter: { op: "eq", field: "message_id", value: message_id },
+      orderBy: [{ field: "id", direction: "asc" }]
+    });
+    return rows.map(
+      (row) => ({ ...row.data, id: row.id, sessionID: row.session_id, messageID: row.message_id })
+    );
+  }
+  MessageV22.parts = parts;
+  async function get(context, input) {
+    const row = context.db.findOne(
+      "message",
+      { op: "and", conditions: [{ op: "eq", field: "id", value: input.messageID }, { op: "eq", field: "session_id", value: input.sessionID }] }
+    );
+    if (!row) throw new NotFoundError({ message: `Message not found: ${input.messageID}` });
+    return {
+      info: info(row),
+      parts: await parts(context, input.messageID)
+    };
+  }
+  MessageV22.get = get;
+  async function filterCompacted(stream2) {
+    const result = [];
+    const completed = /* @__PURE__ */ new Set();
+    for await (const msg of stream2) {
+      result.push(msg);
+      if (msg.info.role === "user" && completed.has(msg.info.id) && msg.parts.some((part2) => part2.type === "compaction"))
+        break;
+      if (msg.info.role === "assistant" && msg.info.summary && msg.info.finish && !msg.info.error)
+        completed.add(msg.info.parentID);
+    }
+    result.reverse();
+    return result;
+  }
+  MessageV22.filterCompacted = filterCompacted;
+  function fromError(e, ctx) {
+    switch (true) {
+      case (e instanceof DOMException && e.name === "AbortError"):
+        return new MessageV22.AbortedError(
+          { message: e.message },
+          {
+            cause: e
+          }
+        ).toObject();
+      case MessageV22.OutputLengthError.isInstance(e):
+        return e;
+      case LoadAPIKeyError.isInstance(e):
+        return new MessageV22.AuthError(
+          {
+            providerID: ctx.providerID,
+            message: e.message
+          },
+          { cause: e }
+        ).toObject();
+      case e?.code === "ECONNRESET":
+        return new MessageV22.APIError(
+          {
+            message: "Connection reset by server",
+            isRetryable: true,
+            metadata: {
+              code: e.code ?? "",
+              syscall: e.syscall ?? "",
+              message: e.message ?? ""
+            }
+          },
+          { cause: e }
+        ).toObject();
+      case APICallError.isInstance(e):
+        const parsed = ProviderError.parseAPICallError({
+          providerID: ctx.providerID,
+          error: e
+        });
+        if (parsed.type === "context_overflow") {
+          return new MessageV22.ContextOverflowError(
+            {
+              message: parsed.message,
+              responseBody: parsed.responseBody
+            },
+            { cause: e }
+          ).toObject();
+        }
+        return new MessageV22.APIError(
+          {
+            message: parsed.message,
+            statusCode: parsed.statusCode,
+            isRetryable: parsed.isRetryable,
+            responseHeaders: parsed.responseHeaders,
+            responseBody: parsed.responseBody,
+            metadata: parsed.metadata
+          },
+          { cause: e }
+        ).toObject();
+      case e instanceof Error:
+        return new NamedError.Unknown({ message: e.toString() }, { cause: e }).toObject();
+      default:
+        try {
+          const parsed2 = ProviderError.parseStreamError(e);
+          if (parsed2) {
+            if (parsed2.type === "context_overflow") {
+              return new MessageV22.ContextOverflowError(
+                {
+                  message: parsed2.message,
+                  responseBody: parsed2.responseBody
+                },
+                { cause: e }
+              ).toObject();
+            }
+            return new MessageV22.APIError(
+              {
+                message: parsed2.message,
+                isRetryable: parsed2.isRetryable,
+                responseBody: parsed2.responseBody
+              },
+              {
+                cause: e
+              }
+            ).toObject();
+          }
+        } catch {
+        }
+        return new NamedError.Unknown({ message: JSON.stringify(e) }, { cause: e }).toObject();
+    }
+  }
+  MessageV22.fromError = fromError;
+})(MessageV2 || (MessageV2 = {}));
+var MemoryService = class extends EventEmitter {
+  constructor(context) {
+    super();
+    this.context = context;
+  }
+  async updateMessage(msg) {
+    const time_created = msg.time.created;
+    const { id, sessionID, ...data } = msg;
+    this.context.db.upsert(
+      "message",
+      { id, session_id: sessionID, time_created, data },
+      ["id"],
+      { data }
+    );
+    this.emit("message.updated", { info: msg });
+    return msg;
+  }
+  async removeMessage(input) {
+    this.context.db.remove(
+      "message",
+      { op: "and", conditions: [{ op: "eq", field: "id", value: input.messageID }, { op: "eq", field: "session_id", value: input.sessionID }] }
+    );
+    this.emit("message.removed", {
+      sessionID: input.sessionID,
+      messageID: input.messageID
+    });
+  }
+  async removePart(input) {
+    this.context.db.remove(
+      "part",
+      { op: "and", conditions: [{ op: "eq", field: "id", value: input.partID }, { op: "eq", field: "session_id", value: input.sessionID }] }
+    );
+    this.emit("message.part.removed", {
+      sessionID: input.sessionID,
+      messageID: input.messageID,
+      partID: input.partID
+    });
+  }
+  async updatePart(part) {
+    const { id, messageID, sessionID, ...data } = part;
+    const time = Date.now();
+    this.context.db.upsert(
+      "part",
+      { id, message_id: messageID, session_id: sessionID, time_created: time, data },
+      ["id"],
+      { data }
+    );
+    this.emit("message.part.updated", { part: structuredClone(part) });
+    return part;
+  }
+  async updatePartDelta(input) {
+    this.emit("message.part.delta", input);
+  }
+  async messages(input) {
+    const result = [];
+    for await (const msg of MessageV2.stream(this.context, input.sessionID)) {
+      if (input.limit && result.length >= input.limit) break;
+      result.push(msg);
+    }
+    result.reverse();
+    return result;
+  }
+};
+var Memory;
+((Memory2) => {
+  Memory2.getUsage = fn(
+    z5.object({
+      model: z5.custom(),
+      usage: z5.custom(),
+      metadata: z5.custom().optional()
+    }),
+    (input) => {
+      const safe = (value) => {
+        if (!Number.isFinite(value)) return 0;
+        return value;
+      };
+      const inputTokens = safe(input.usage.inputTokens ?? 0);
+      const outputTokens = safe(input.usage.outputTokens ?? 0);
+      const reasoningTokens = safe(input.usage.reasoningTokens ?? 0);
+      const cacheReadInputTokens = safe(input.usage.cachedInputTokens ?? 0);
+      const cacheWriteInputTokens = safe(
+        input.metadata?.["anthropic"]?.["cacheCreationInputTokens"] ?? // @ts-expect-error
+        input.metadata?.["bedrock"]?.["usage"]?.["cacheWriteInputTokens"] ?? // @ts-expect-error
+        input.metadata?.["venice"]?.["usage"]?.["cacheCreationInputTokens"] ?? 0
+      );
+      const excludesCachedTokens = !!(input.metadata?.["anthropic"] || input.metadata?.["bedrock"]);
+      const adjustedInputTokens = safe(
+        excludesCachedTokens ? inputTokens : inputTokens - cacheReadInputTokens - cacheWriteInputTokens
+      );
+      const total = iife(() => {
+        if (input.model.api.npm === "@ai-sdk/anthropic" || input.model.api.npm === "@ai-sdk/amazon-bedrock" || input.model.api.npm === "@ai-sdk/google-vertex/anthropic") {
+          return adjustedInputTokens + outputTokens + cacheReadInputTokens + cacheWriteInputTokens;
+        }
+        return input.usage.totalTokens;
+      });
+      const tokens = {
+        total,
+        input: adjustedInputTokens,
+        output: outputTokens,
+        reasoning: reasoningTokens,
+        cache: {
+          write: cacheWriteInputTokens,
+          read: cacheReadInputTokens
+        }
+      };
+      const costInfo = input.model.cost?.experimentalOver200K && tokens.input + tokens.cache.read > 2e5 ? input.model.cost.experimentalOver200K : input.model.cost;
+      return {
+        cost: safe(
+          new Decimal(0).add(new Decimal(tokens.input).mul(costInfo?.input ?? 0).div(1e6)).add(new Decimal(tokens.output).mul(costInfo?.output ?? 0).div(1e6)).add(new Decimal(tokens.cache.read).mul(costInfo?.cache?.read ?? 0).div(1e6)).add(new Decimal(tokens.cache.write).mul(costInfo?.cache?.write ?? 0).div(1e6)).add(new Decimal(tokens.reasoning).mul(costInfo?.output ?? 0).div(1e6)).toNumber()
+        ),
+        tokens
+      };
+    }
+  );
+})(Memory || (Memory = {}));
+var WorkspaceID = { zod: z6.string() };
+var WorkspaceContext = { workspaceID: void 0 };
+var log = Log.create({ service: "session" });
+var parentTitlePrefix = "New session - ";
+var childTitlePrefix = "Child session - ";
+function createDefaultTitle(isChild = false) {
+  return (isChild ? childTitlePrefix : parentTitlePrefix) + (/* @__PURE__ */ new Date()).toISOString();
+}
+function fromRow(row) {
+  const summary = row.summary_additions !== null || row.summary_deletions !== null || row.summary_files !== null ? {
+    additions: row.summary_additions ?? 0,
+    deletions: row.summary_deletions ?? 0,
+    files: row.summary_files ?? 0,
+    diffs: row.summary_diffs ?? void 0
+  } : void 0;
+  return {
+    id: row.id,
+    slug: row.slug,
+    projectID: row.project_id,
+    workspaceID: row.workspace_id ?? void 0,
+    directory: row.directory,
+    parentID: row.parent_id ?? void 0,
+    title: row.title,
+    version: row.version,
+    summary,
+    revert: row.revert ?? void 0,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated,
+      compacting: row.time_compacting ?? void 0,
+      archived: row.time_archived ?? void 0
+    }
+  };
+}
+function toRow(info) {
+  return {
+    id: info.id,
+    project_id: info.projectID,
+    workspace_id: info.workspaceID,
+    parent_id: info.parentID,
+    slug: info.slug,
+    directory: info.directory,
+    title: info.title,
+    version: info.version,
+    share_url: void 0,
+    summary_additions: info.summary?.additions,
+    summary_deletions: info.summary?.deletions,
+    summary_files: info.summary?.files,
+    summary_diffs: info.summary?.diffs,
+    revert: info.revert ?? null,
+    time_created: info.time.created,
+    time_updated: info.time.updated,
+    time_compacting: info.time.compacting,
+    time_archived: info.time.archived
+  };
+}
+var SessionService = class extends EventEmitter2 {
+  constructor(ctx) {
+    super();
+    this.ctx = ctx;
+  }
+  static isDefaultTitle(title) {
+    return new RegExp(
+      `^(${parentTitlePrefix}|${childTitlePrefix})\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$`
+    ).test(title);
+  }
+  static fromRow = fromRow;
+  static toRow = toRow;
+  static getUsage = Memory.getUsage;
+  async create(input) {
+    return this.createNext({
+      parentID: input?.parentID,
+      directory: this.ctx.directory,
+      title: input?.title,
+      workspaceID: input?.workspaceID
+    });
+  }
+  async touch(sessionID) {
+    const now = Date.now();
+    {
+      const row = this.ctx.db.update(
+        "session",
+        { op: "eq", field: "id", value: sessionID },
+        { time_updated: now }
+      );
+      if (!row) throw new NotFoundError({ message: `Session not found: ${sessionID}` });
+      const info = fromRow(row);
+      this.emit("session.updated", { info });
+    }
+  }
+  async createNext(input) {
+    const result = {
+      id: SessionID.descending(input.id),
+      slug: Slug.create(),
+      version: Installation.VERSION,
+      projectID: this.ctx.project.id,
+      directory: input.directory,
+      workspaceID: input.workspaceID,
+      parentID: input.parentID,
+      title: input.title ?? createDefaultTitle(!!input.parentID),
+      time: {
+        created: Date.now(),
+        updated: Date.now()
+      }
+    };
+    log.info("created", result);
+    {
+      this.ctx.db.insert("session", toRow(result));
+      this.emit("session.created", { info: result });
+    }
+    this.emit("session.updated", { info: result });
+    return result;
+  }
+  plan(input) {
+    const base = this.ctx.project.vcs ? join(this.ctx.worktree, ".opencode", "plans") : join(this.ctx.dataPath, "plans");
+    return join(base, [input.time.created, input.slug].join("-") + ".md");
+  }
+  async get(id) {
+    const row = this.ctx.db.findOne("session", { op: "eq", field: "id", value: id });
+    if (!row) throw new NotFoundError({ message: `Session not found: ${id}` });
+    return fromRow(row);
+  }
+  async setTitle(input) {
+    const row = this.ctx.db.update(
+      "session",
+      { op: "eq", field: "id", value: input.sessionID },
+      { title: input.title }
+    );
+    if (!row) throw new NotFoundError({ message: `Session not found: ${input.sessionID}` });
+    const info = fromRow(row);
+    this.emit("session.updated", { info });
+    return info;
+  }
+  async messages(input) {
+    return this.ctx.memory.messages(input);
+  }
+  *list(input) {
+    const project = this.ctx.project;
+    const conditions = [{ op: "eq", field: "project_id", value: project.id }];
+    if (WorkspaceContext.workspaceID) {
+      conditions.push({ op: "eq", field: "workspace_id", value: WorkspaceContext.workspaceID });
+    }
+    if (input?.directory) {
+      conditions.push({ op: "eq", field: "directory", value: input.directory });
+    }
+    if (input?.roots) {
+      conditions.push({ op: "isNull", field: "parent_id" });
+    }
+    if (input?.start) {
+      conditions.push({ op: "gte", field: "time_updated", value: input.start });
+    }
+    if (input?.search) {
+      conditions.push({ op: "like", field: "title", value: `%${input.search}%` });
+    }
+    const limit = input?.limit ?? 100;
+    const rows = this.ctx.db.findMany("session", {
+      filter: { op: "and", conditions },
+      orderBy: [{ field: "time_updated", direction: "desc" }],
+      limit
+    });
+    for (const row of rows) {
+      yield fromRow(row);
+    }
+  }
+  *listGlobal(input) {
+    const conditions = [];
+    if (input?.directory) {
+      conditions.push({ op: "eq", field: "directory", value: input.directory });
+    }
+    if (input?.roots) {
+      conditions.push({ op: "isNull", field: "parent_id" });
+    }
+    if (input?.start) {
+      conditions.push({ op: "gte", field: "time_updated", value: input.start });
+    }
+    if (input?.cursor) {
+      conditions.push({ op: "lt", field: "time_updated", value: input.cursor });
+    }
+    if (input?.search) {
+      conditions.push({ op: "like", field: "title", value: `%${input.search}%` });
+    }
+    if (!input?.archived) {
+      conditions.push({ op: "isNull", field: "time_archived" });
+    }
+    const limit = input?.limit ?? 100;
+    const rows = this.ctx.db.findMany("session", {
+      filter: conditions.length > 0 ? { op: "and", conditions } : void 0,
+      orderBy: [{ field: "time_updated", direction: "desc" }, { field: "id", direction: "desc" }],
+      limit
+    });
+    const ids = [...new Set(rows.map((row) => row.project_id))];
+    const projects = /* @__PURE__ */ new Map();
+    if (ids.length > 0) {
+      const items = this.ctx.db.findMany("project", {
+        filter: { op: "in", field: "id", values: ids },
+        select: ["id", "name", "worktree"]
+      });
+      for (const item of items) {
+        projects.set(item.id, {
+          id: item.id,
+          name: item.name ?? void 0,
+          worktree: item.worktree
+        });
+      }
+    }
+    for (const row of rows) {
+      const project = projects.get(row.project_id) ?? null;
+      yield { ...fromRow(row), project };
+    }
+  }
+  async updateMessage(msg) {
+    return this.ctx.memory.updateMessage(msg);
+  }
+  async removeMessage(input) {
+    return this.ctx.memory.removeMessage(input);
+  }
+  async removePart(input) {
+    return this.ctx.memory.removePart(input);
+  }
+  async updatePart(part) {
+    return this.ctx.memory.updatePart(part);
+  }
+  async updatePartDelta(input) {
+    return this.ctx.memory.updatePartDelta(input);
+  }
+  updateTodo(input) {
+    this.ctx.db.transaction((tx) => {
+      tx.remove("todo", { op: "eq", field: "session_id", value: input.sessionID });
+      if (input.todos.length === 0) return;
+      for (const [position, todo] of input.todos.entries()) {
+        tx.insert("todo", {
+          session_id: input.sessionID,
+          content: todo.content,
+          status: todo.status,
+          priority: todo.priority,
+          position
+        });
+      }
+    });
+    this.emit("todo.updated", input);
+  }
+  getTodo(sessionID) {
+    const rows = this.ctx.db.findMany("todo", {
+      filter: { op: "eq", field: "session_id", value: sessionID },
+      orderBy: [{ field: "position", direction: "asc" }]
+    });
+    return rows.map((row) => ({
+      content: row.content,
+      status: row.status,
+      priority: row.priority
+    }));
+  }
+};
+var Session;
+((Session2) => {
+  Session2.Info = z6.object({
+    id: SessionID.zod,
+    slug: z6.string(),
+    projectID: ProjectID.zod,
+    workspaceID: WorkspaceID.zod.optional(),
+    directory: z6.string(),
+    parentID: SessionID.zod.optional(),
+    summary: z6.object({
+      additions: z6.number(),
+      deletions: z6.number(),
+      files: z6.number(),
+      diffs: MessageV2.FileDiff.array().optional()
+    }).optional(),
+    title: z6.string(),
+    version: z6.string(),
+    time: z6.object({
+      created: z6.number(),
+      updated: z6.number(),
+      compacting: z6.number().optional(),
+      archived: z6.number().optional()
+    }),
+    revert: z6.object({
+      messageID: MessageID.zod,
+      partID: PartID.zod.optional(),
+      diff: z6.string().optional()
+    }).optional()
+  }).meta({
+    ref: "Session"
+  });
+  Session2.ProjectInfo = z6.object({
+    id: ProjectID.zod,
+    name: z6.string().optional(),
+    worktree: z6.string()
+  }).meta({
+    ref: "ProjectSummary"
+  });
+  Session2.GlobalInfo = Session2.Info.extend({
+    project: Session2.ProjectInfo.nullable()
+  }).meta({
+    ref: "GlobalSession"
+  });
+  class BusyError extends Error {
+    constructor(sessionID) {
+      super(`Session ${sessionID} is busy`);
+      this.sessionID = sessionID;
+    }
+  }
+  Session2.BusyError = BusyError;
+})(Session || (Session = {}));
+var SessionStatus;
+((SessionStatus2) => {
+  SessionStatus2.Info = z6.union([
+    z6.object({
+      type: z6.literal("idle")
+    }),
+    z6.object({
+      type: z6.literal("retry"),
+      attempt: z6.number(),
+      message: z6.string(),
+      next: z6.number()
+    }),
+    z6.object({
+      type: z6.literal("busy")
+    })
+  ]).meta({
+    ref: "SessionStatus"
+  });
+})(SessionStatus || (SessionStatus = {}));
+var Todo;
+((Todo2) => {
+  Todo2.Info = z6.object({
+    content: z6.string().describe("Brief description of the task"),
+    status: z6.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
+    priority: z6.string().describe("Priority level of the task: high, medium, low")
+  }).meta({ ref: "Todo" });
+})(Todo || (Todo = {}));
+
+export {
+  Installation,
+  LSP,
+  iife,
+  defer,
+  Token,
+  ProviderID,
+  ModelID,
+  MessageV2,
+  MemoryService,
+  SessionService,
+  Session,
+  SessionStatus,
+  Todo
+};