anycodex 0.0.3 → 0.0.4

package/dist/chunk-TDYQG5PB.js

@@ -1,1621 +0,0 @@
-#!/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
-};