@opencode/core 0.0.0-dev-19400 → 0.0.0-dev-19403

package/dist/chunks/credential-wk4y5nr3.js

@@ -0,0 +1,260 @@
+import {
+  Metadata2,
+  useragent2,
+  node80
+} from "./credential-wak322rn.js";
+import {
+  provenance2,
+  compatible2
+} from "./credential-rsdf2nvv.js";
+import {
+  Service75,
+  node78
+} from "./credential-xgsrhv1b.js";
+import {
+  DeclinedError2
+} from "./credential-exfykm2r.js";
+import {
+  CancelledError2
+} from "./credential-69n4s4c8.js";
+import {
+  Error4
+} from "./credential-0wf9s8aa.js";
+import {
+  Service34,
+  node38
+} from "./credential-qdtgw5bq.js";
+import {
+  make15
+} from "./credential-hjt4xg1x.js";
+import {
+  toLLMMessages2
+} from "./credential-wx9wy1qm.js";
+import {
+  __export
+} from "./credential-9rqn6x4v.js";
+
+// src/session/model-request.ts
+var exports_model_request = {};
+__export(exports_model_request, {
+  Service: () => Service33,
+  SessionModelRequest: () => exports_model_request,
+  baseTranscript: () => baseTranscript2,
+  boundImages: () => boundImages2,
+  layer: () => layer12,
+  node: () => node37,
+  unsupportedParts: () => unsupportedParts2
+});
+import {
+  GenerationOptions,
+  HttpOptions,
+  LanguageModel,
+  LLM,
+  LLMRequest,
+  Message,
+  SystemPart
+} from "@opencode/ai";
+import { Cause, Context, Effect, Layer, Result, Stream } from "effect";
+import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var IMAGE_BYTES_TRIGGER = 25 * 1024 * 1024;
+var IMAGE_BYTES_TARGET = 15 * 1024 * 1024;
+var IMAGE_REMOVED = "[This image was removed to reduce the request size and is no longer visible. Do not make claims about its contents from memory. If needed, retrieve it again with an available tool or ask the user to attach it again.]";
+var GENERATION_KEYS = new Set(Object.keys(GenerationOptions.fields));
+var baseTranscript2 = (input) => {
+  const providerMetadataKey = input.model.model.route.providerMetadataKey ?? input.model.model.provider;
+  return {
+    providerMetadataKey,
+    system: [
+      input.agent.system ? input.agent.system : make15(input.tools.definitions.map((tool) => tool.name)),
+      input.initial
+    ].filter((part) => part.length > 0).map(SystemPart.make),
+    messages: toLLMMessages2(input.messages, input.model.ref, providerMetadataKey)
+  };
+};
+var mimeToModality = (mime) => {
+  if (mime.startsWith("image/"))
+    return "image";
+  if (mime.startsWith("audio/"))
+    return "audio";
+  if (mime.startsWith("video/"))
+    return "video";
+  if (mime === "application/pdf")
+    return "pdf";
+};
+var unsupportedMedia = (mime, name, capabilities) => {
+  const modality = mimeToModality(mime);
+  if (!modality || capabilities.input.some((item) => item.startsWith(modality)))
+    return;
+  return {
+    type: "text",
+    text: `ERROR: Cannot read ${name ? `"${name}"` : modality} (this model does not support ${modality} input). Inform the user.`
+  };
+};
+var unsupportedParts2 = (messages, capabilities) => messages.map((message) => Message.make({
+  ...message,
+  content: message.content.map((part) => {
+    if (part.type === "media") {
+      return unsupportedMedia(part.mediaType, part.filename, capabilities) ?? part;
+    }
+    if (part.type !== "tool-result" || part.result.type !== "content")
+      return part;
+    return {
+      ...part,
+      result: {
+        ...part.result,
+        value: part.result.value.map((item) => {
+          if (item.type !== "file")
+            return item;
+          return unsupportedMedia(item.mime, item.name, capabilities) ?? item;
+        })
+      }
+    };
+  })
+}));
+var boundImages2 = (messages) => {
+  const isImage = (mime) => mime.toLowerCase().startsWith("image/");
+  const size = (data) => typeof data === "string" ? Buffer.byteLength(data) : Math.ceil(data.byteLength / 3) * 4;
+  const imageBytes = messages.reduce((total, message) => total + message.content.reduce((sum, part) => {
+    if (part.type === "media" && isImage(part.mediaType))
+      return sum + size(part.data);
+    if (part.type !== "tool-result" || part.result.type !== "content")
+      return sum;
+    return sum + part.result.value.reduce((bytes, item) => bytes + (item.type === "file" && isImage(item.mime) ? Buffer.byteLength(item.uri) : 0), 0);
+  }, 0), 0);
+  if (imageBytes <= IMAGE_BYTES_TRIGGER)
+    return messages;
+  let removed = 0;
+  return messages.map((message) => Message.make({
+    ...message,
+    content: message.content.map((part) => {
+      if (part.type === "media" && isImage(part.mediaType) && imageBytes - removed > IMAGE_BYTES_TARGET) {
+        removed += size(part.data);
+        return Message.text(IMAGE_REMOVED);
+      }
+      if (part.type !== "tool-result" || part.result.type !== "content")
+        return part;
+      return {
+        ...part,
+        result: {
+          ...part.result,
+          value: part.result.value.map((item) => {
+            if (item.type !== "file" || !isImage(item.mime) || imageBytes - removed <= IMAGE_BYTES_TARGET)
+              return item;
+            removed += Buffer.byteLength(item.uri);
+            return { type: "text", text: IMAGE_REMOVED };
+          })
+        }
+      };
+    })
+  }));
+};
+
+class Service33 extends Context.Service()("@opencode/SessionModelRequest") {
+}
+var layer12 = Layer.effect(Service33, Effect.gen(function* () {
+  const hooks = yield* Service75;
+  const transport = yield* Service34;
+  const app = yield* Metadata2;
+  const prepare = Effect.fn("SessionModelRequest.prepare")(function* (kind, input, shape) {
+    const session = input.session;
+    const model = input.model;
+    const scope = { sessionID: session.id, agent: input.agent, model: model.ref, kind };
+    const tools = input.tools ?? {
+      definitions: [],
+      execute: () => new Error4({ message: "Tools are not available for this request" })
+    };
+    const given = new Map(tools.definitions.map((t) => [{ description: t.description, input: { ...t.inputSchema } }, t]));
+    const shaped = yield* shape({ sessionID: session.id, model: model.ref, system: input.system, messages: input.messages, options: {} }, Object.fromEntries(Array.from(given, ([d, t]) => [t.name, d])));
+    const byName = new Map(tools.definitions.map((t) => [t.name, t]));
+    const hooked = new Map(Object.entries(shaped.tools ?? {}).flatMap(([name, d]) => {
+      const t = given.get(d) ?? byName.get(name);
+      return t ? [[name, { ...t, description: d.description, inputSchema: d.input }]] : [];
+    }));
+    const entries = Object.entries(shaped.options);
+    const generation = Object.fromEntries(entries.filter(([k]) => GENERATION_KEYS.has(k)));
+    const providerOptions = Object.fromEntries(entries.filter(([k]) => !GENERATION_KEYS.has(k)));
+    const root = session.fork?.sessionID ?? session.id;
+    const base = LLM.request({
+      model: model.model,
+      http: {
+        headers: {
+          "x-session-affinity": session.id,
+          "X-Session-Id": session.id,
+          ...session.parentID ? { "x-parent-session-id": session.parentID } : {},
+          "User-Agent": useragent2(app),
+          "x-opencode-project": session.projectID,
+          "x-opencode-session": session.id,
+          "x-opencode-client": app.name
+        }
+      },
+      promptCacheKey: /^ses_[0-9a-f]{64}$/.test(root) ? root.slice(4) : root,
+      system: shaped.system,
+      messages: boundImages2(unsupportedParts2(shaped.messages, model.capabilities)),
+      tools: Array.from(hooked, ([name, t]) => ({ ...t, name })),
+      toolChoice: input.toolChoice,
+      generation: Object.keys(generation).length === 0 ? undefined : generation,
+      providerOptions: Object.keys(providerOptions).length === 0 ? undefined : providerOptions
+    });
+    const baseURL = base.model.route.endpoint.baseURL;
+    const modelHook = yield* hooks.trigger("session", "model.request", {
+      ...scope,
+      baseURL: typeof baseURL === "string" ? baseURL : undefined,
+      headers: { ...base.http?.headers }
+    });
+    const route = modelHook.baseURL !== undefined && modelHook.baseURL !== baseURL ? base.model.route.with({ endpoint: { baseURL: modelHook.baseURL } }) : base.model.route;
+    const request = LLMRequest.update(base, {
+      model: route === base.model.route ? base.model : LanguageModel.update(base.model, { route }),
+      http: new HttpOptions({
+        body: base.http?.body,
+        headers: Object.keys(modelHook.headers).length === 0 ? undefined : modelHook.headers,
+        query: base.http?.query
+      })
+    });
+    const selected = provenance2(model);
+    if (selected && !compatible2(selected, provenance2({ model: request.model, ref: model.ref })) && request.messages.some((message) => message.content.some((part) => part.type === "compaction")))
+      return yield* Effect.die(new Error("Provider context is incompatible with the route selected by model request hooks"));
+    const hasHttpHooks = (yield* hooks.has("session", "http.request", model.ref.providerID)) || (yield* hooks.has("session", "http.response", model.ref.providerID));
+    const http = hasHttpHooks ? (req, handler) => Effect.gen(function* () {
+      const before = yield* hooks.trigger("session", "http.request", {
+        ...scope,
+        request: yield* HttpClientRequest.toWeb(req)
+      });
+      let sent = HttpClientRequest.fromWeb(before.request);
+      if (before.request.body)
+        sent = HttpClientRequest.bodyUint8Array(sent, new Uint8Array(yield* Effect.promise(() => before.request.clone().arrayBuffer())), before.request.headers.get("content-type") ?? undefined);
+      const res = yield* handler(sent);
+      const after = yield* hooks.trigger("session", "http.response", {
+        ...scope,
+        request: before.request,
+        response: new Response([204, 205, 304].includes(res.status) ? null : yield* Stream.toReadableStreamEffect(res.stream), { status: res.status, headers: res.headers })
+      });
+      return HttpClientResponse.fromWeb(sent, after.response);
+    }).pipe(Effect.mapError((cause) => cause instanceof Error ? cause : new Error(String(cause)))) : undefined;
+    const webSocket = input.webSocket === "session" && !hasHttpHooks && model.capabilities.responsesWebsockets === true && model.websocket;
+    return {
+      event: shaped,
+      request,
+      options: { ...http ? { http } : {}, ...webSocket ? { webSocket: transport.bind(session.id) } : {} },
+      retry: (event) => hooks.trigger("session", "retry", event).pipe(Effect.asVoid),
+      executeTool: (call) => tools.execute({ ...call, definitions: hooked }).pipe(Effect.catchCauseFilter((cause) => {
+        const decline = cause.reasons.flatMap((r) => Cause.isDieReason(r) && (r.defect instanceof DeclinedError2 || r.defect instanceof CancelledError2) ? [r.defect] : [])[0];
+        return decline ? Result.succeed(decline) : Result.fail(cause);
+      }, (decline) => Effect.fail(decline)))
+    };
+  });
+  const context = (agent) => (draft, tools) => hooks.trigger("session", "context", { ...draft, agent, tools });
+  return Service33.of({
+    primary: (input) => prepare("primary", input, context(input.agent)),
+    generate: (input) => prepare("generate", input, context(input.agent)),
+    compaction: (input) => prepare("compaction", input, context(input.agent)),
+    title: (input) => prepare("title", input, (draft) => hooks.trigger("session", "title", draft))
+  });
+}));
+var node37 = makeLocationNode({
+  service: Service33,
+  layer: layer12,
+  deps: [node78, node38, node80]
+});
+
+export { baseTranscript2, unsupportedParts2, boundImages2, Service33, layer12, node37, exports_model_request };

package/dist/chunks/{worktree-qezjrgcf.js → credential-wq8n05qc.js}

@@ -1,34 +1,34 @@
 import {
   Service80
-} from "./worktree-g2r6x3tk.js";
+} from "./credential-r6teeq8r.js";
 import {
-  Service79
-} from "./worktree-1k4ezpe5.js";
+  Service78
+} from "./credential-3kyqxgv1.js";
 import {
-  Service40
-} from "./worktree-qfzde7bh.js";
+  Service50
+} from "./credential-hq8zt1th.js";
 import {
   RelativePath2
-} from "./worktree-922hggd3.js";
+} from "./credential-922hggd3.js";
 import {
-  ID8,
-  Service48
-} from "./worktree-2bbm4yb8.js";
+  ID13,
+  Service69
+} from "./credential-686gxxnm.js";
 import {
   SessionEvent2
-} from "./worktree-ec1grn59.js";
+} from "./credential-ec1grn59.js";
 import {
   SessionMessage2
-} from "./worktree-gftt206x.js";
+} from "./credential-gftt206x.js";
 import {
   MessageNotFoundError2
-} from "./worktree-k6z6zgfk.js";
+} from "./credential-vbah0zve.js";
 import {
   SessionMessageTable2
-} from "./worktree-a1bz86dw.js";
+} from "./credential-a1bz86dw.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./credential-9rqn6x4v.js";
 
 // src/session/revert.ts
 var exports_revert = {};
@@ -42,12 +42,12 @@ __export(exports_revert, {
 import { and, asc, eq, gt } from "drizzle-orm";
 import { Effect, Schema } from "effect";
 var stage2 = Effect.fn("SessionRevert.stage")(function* (input) {
-  const instances = yield* Service40;
+  const instances = yield* Service50;
   const database = yield* Service80;
-  const bus = yield* Service79;
+  const bus = yield* Service78;
   return yield* Effect.gen(function* () {
-    const snapshot = yield* Service48;
-    const original = input.session.revert?.snapshot ? ID8.make(input.session.revert.snapshot) : yield* snapshot.capture();
+    const snapshot = yield* Service69;
+    const original = input.session.revert?.snapshot ? ID13.make(input.session.revert.snapshot) : yield* snapshot.capture();
     const next = yield* plan(database.db, { sessionID: input.session.id, messageID: input.messageID });
     const restore = new Map;
     if (original) {
@@ -74,13 +74,13 @@ var stage2 = Effect.fn("SessionRevert.stage")(function* (input) {
   }).pipe(instances.provide(input.session));
 });
 var clear2 = Effect.fn("SessionRevert.clear")(function* (session) {
-  const instances = yield* Service40;
-  const bus = yield* Service79;
+  const instances = yield* Service50;
+  const bus = yield* Service78;
   yield* Effect.gen(function* () {
-    const snapshot = yield* Service48;
+    const snapshot = yield* Service69;
     if (!session.revert)
       return;
-    const original = session.revert.snapshot ? ID8.make(session.revert.snapshot) : undefined;
+    const original = session.revert.snapshot ? ID13.make(session.revert.snapshot) : undefined;
     if (original)
       yield* snapshot.restore({
         files: new Map((session.revert.files ?? []).map((file) => [RelativePath2.make(file.file), original]))
@@ -111,7 +111,7 @@ var plan = Effect.fn("SessionRevert.plan")(function* (db, input) {
       continue;
     for (const file of message.snapshot.files ?? [])
       if (!files.has(file))
-        files.set(file, ID8.make(message.snapshot.start));
+        files.set(file, ID13.make(message.snapshot.start));
   }
   return files;
 });

package/dist/chunks/{worktree-0rstx4q2.js → credential-wtpfkq3a.js}

@@ -2,16 +2,16 @@ import {
   managesTransactionsNatively2,
   EffectSQLiteSession2,
   EffectSQLiteTransaction2
-} from "./worktree-81enad2h.js";
+} from "./credential-mscwsevq.js";
 import {
   EffectSQLiteDatabase2,
   DefaultServices2,
   make23,
   makeWithDefaults2
-} from "./worktree-n6a4148r.js";
+} from "./credential-hfgsy8qe.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./credential-9rqn6x4v.js";
 
 // src/database/drizzle/index.ts
 var exports_drizzle = {};

package/dist/chunks/{worktree-9cdxmsp5.js → credential-wtrmr3z3.js}

@@ -1,47 +1,47 @@
 import {
-  ID13,
-  Service70
-} from "./worktree-w74v902z.js";
+  ID11,
+  Service68
+} from "./credential-jwbr3km5.js";
 import {
   latest2,
-  Service56
-} from "./worktree-arv4s5vt.js";
+  Service43
+} from "./credential-78mn15xw.js";
 import {
   SessionSchema2
-} from "./worktree-539jk4fq.js";
+} from "./credential-bwshncvd.js";
 import {
-  Service42
-} from "./worktree-atxwy4st.js";
+  Service56
+} from "./credential-vd169w8v.js";
 import {
   evaluate2,
-  Service67
-} from "./worktree-884je023.js";
+  Service65
+} from "./credential-exfykm2r.js";
 import {
-  Service23
-} from "./worktree-tw3b2c1y.js";
+  Service24
+} from "./credential-909pcchj.js";
 import {
   NO_TEXT2
-} from "./worktree-x1ezjp6w.js";
+} from "./credential-x1ezjp6w.js";
 import {
-  make9
-} from "./worktree-zsedakp3.js";
+  make8
+} from "./credential-2kgfnkh5.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./credential-9rqn6x4v.js";
 
 // src/tool/plugin/subagent.ts
 var exports_subagent = {};
 __export(exports_subagent, {
-  Input: () => Input8,
-  Output: () => Output6,
-  Plugin: () => Plugin9,
+  Input: () => Input2,
+  Output: () => Output2,
+  Plugin: () => Plugin15,
   SubagentTool: () => exports_subagent,
-  description: () => description4,
-  name: () => name8
+  description: () => description2,
+  name: () => name2
 });
 import { ToolFailure } from "@opencode/ai";
 import { Effect, Schema } from "effect";
-var name8 = "subagent";
+var name2 = "subagent";
 var backgroundResult = (sessionID) => ({
   sessionID,
   status: "running",
@@ -52,7 +52,7 @@ var backgroundResult = (sessionID) => ({
   ].join(`
 `)
 });
-var Input8 = Schema.Struct({
+var Input2 = Schema.Struct({
   agent: Schema.String.annotate({ description: "The type of specialized agent to use for this task" }),
   description: Schema.String.annotate({ description: "A short 3-5 word label for the task, displayed to the user" }),
   prompt: Schema.String.annotate({ description: "The task for the subagent to perform" }),
@@ -63,12 +63,12 @@ var Input8 = Schema.Struct({
     description: "Run the subagent in the background and return immediately. You will be notified when it completes. DO NOT sleep, poll, or proactively check on its progress."
   })
 });
-var Output6 = Schema.Struct({
+var Output2 = Schema.Struct({
   sessionID: SessionSchema2.ID,
   status: Schema.Literals(["completed", "running"]),
   output: Schema.String
 });
-var description4 = [
+var description2 = [
   "Spawns an agent in a child session to work on the specified task.",
   "The output includes a sessionID you can pass back later to continue that specific conversation with the subagent.",
   "New child sessions start with fresh context, so include all relevant context and instructions when you don't pass a sessionID.",
@@ -77,21 +77,21 @@ var description4 = [
   "Use background only for independent work that can run while you continue elsewhere."
 ].join(`
 `);
-var Plugin9 = {
+var Plugin15 = {
   id: "opencode.tool.subagent",
   effect: Effect.fn("SubagentTool.Plugin")(function* (ctx) {
-    const sessions = yield* Service23;
-    const jobs = yield* Service42;
-    const agents = yield* Service70;
-    const config = yield* Service56;
-    const permission = yield* Service67;
-    const subagents = yield* make9;
+    const sessions = yield* Service24;
+    const jobs = yield* Service56;
+    const agents = yield* Service68;
+    const config = yield* Service43;
+    const permission = yield* Service65;
+    const subagents = yield* make8;
     yield* ctx.tool.transform((editor) => editor.add({
-      name: name8,
+      name: name2,
       options: { codemode: false },
-      description: description4,
-      input: Input8,
-      output: Output6,
+      description: description2,
+      input: Input2,
+      output: Output2,
       execute: (input, context) => Effect.gen(function* () {
         const parent = yield* sessions.get(context.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error })));
         let current = parent;
@@ -111,7 +111,7 @@ var Plugin9 = {
         if (agent.mode === "primary")
           return yield* new ToolFailure({ message: `Agent ${input.agent} cannot run as a subagent` });
         yield* permission.assert({
-          action: name8,
+          action: name2,
           resources: [agent.id],
           save: [agent.id],
           sessionID: context.sessionID,
@@ -134,7 +134,7 @@ var Plugin9 = {
         const child = existing ?? (yield* sessions.create({
           parentID: context.sessionID,
           title: input.description,
-          agent: ID13.make(input.agent),
+          agent: ID11.make(input.agent),
           model
         }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error }))));
         const background = input.background === true;
@@ -184,13 +184,13 @@ ${output.output}
       })))
     })).pipe(Effect.orDie);
     yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
-      const tool = event.tools[name8];
+      const tool = event.tools[name2];
       if (!tool)
         return;
       const selected = yield* agents.resolve(event.agent);
       if (!selected)
         return;
-      const available = (yield* agents.list()).filter((agent) => agent.mode !== "primary" && !agent.hidden && evaluate2(name8, agent.id, selected.permissions).effect !== "deny").toSorted((a, b) => a.id.localeCompare(b.id));
+      const available = (yield* agents.list()).filter((agent) => agent.mode !== "primary" && !agent.hidden && evaluate2(name2, agent.id, selected.permissions).effect !== "deny").toSorted((a, b) => a.id.localeCompare(b.id));
       if (available.length === 0)
         return;
       tool.description = [
@@ -204,4 +204,4 @@ ${output.output}
   })
 };
 
-export { name8, Input8, Output6, description4, Plugin9, exports_subagent };
+export { name2, Input2, Output2, description2, Plugin15, exports_subagent };

package/dist/chunks/{worktree-wx9wy1qm.js → credential-wx9wy1qm.js}

@@ -1,7 +1,7 @@
 import {
   isCheckpoint2,
   decode2
-} from "./worktree-rsdf2nvv.js";
+} from "./credential-rsdf2nvv.js";
 
 // src/session/runner/to-llm-message.ts
 import { Message, ToolCallPart, ToolResultPart } from "@opencode/ai";

package/dist/chunks/{worktree-mqy0jkn2.js → credential-x0511brf.js}

@@ -1,17 +1,17 @@
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./credential-9rqn6x4v.js";
 
 // src/plugin/mcp-codemode-exclusion.ts
 var exports_mcp_codemode_exclusion = {};
 __export(exports_mcp_codemode_exclusion, {
   McpCodeModeExclusionPlugin: () => exports_mcp_codemode_exclusion,
-  Plugin: () => Plugin23
+  Plugin: () => Plugin14
 });
 import { define } from "@opencode/plugin/effect/plugin";
 import { Effect } from "effect";
 var urls = [/^https:\/\/executor\.sh\/[^/]+\/mcp$/];
-var Plugin23 = define({
+var Plugin14 = define({
   id: "opencode.mcp.codemode.exclusion",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.mcp.transform((editor) => {
@@ -34,4 +34,4 @@ var Plugin23 = define({
   })
 });
 
-export { Plugin23, exports_mcp_codemode_exclusion };
+export { Plugin14, exports_mcp_codemode_exclusion };

package/dist/chunks/{worktree-x1ezjp6w.js → credential-x1ezjp6w.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./credential-9rqn6x4v.js";
 
 // src/session/subagent-completion.ts
 var exports_subagent_completion = {};