@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-0zz82cjq.js

@@ -0,0 +1,17 @@
+// src/plugin/provider/factory.ts
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+function createProviderPlugin(input) {
+  return define({
+    id: input.id,
+    effect: Effect.fn(function* (ctx) {
+      yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+        if (evt.package !== input.package)
+          return;
+        evt.sdk = yield* Effect.promise(() => input.load(evt.options));
+      }));
+    })
+  });
+}
+
+export { createProviderPlugin };

package/dist/chunks/ripgrep-10xtr3be.js

@@ -0,0 +1,34 @@
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/provider/cerebras.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var CerebrasPlugin = define({
+  id: "opencode.provider.cerebras",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/cerebras")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "X-Cerebras-3rd-Party-Integration": "opencode" };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "@ai-sdk/cerebras")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/cerebras"));
+      evt.sdk = mod.createCerebras(evt.options);
+    }));
+  })
+});
+
+export { CerebrasPlugin };

package/dist/chunks/ripgrep-18pv8fg3.js

@@ -0,0 +1,98 @@
+import {
+  PositiveInt
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/provider.ts
+var exports_provider = {};
+__export(exports_provider, {
+  ModelStatus: () => ModelStatus,
+  Model: () => Model,
+  Info: () => Info,
+  ConfigProviderV1: () => exports_provider
+});
+import { Schema } from "effect";
+var ModelStatus = Schema.Literals(["alpha", "beta", "deprecated", "active"]);
+var Model = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  family: Schema.optional(Schema.String),
+  release_date: Schema.optional(Schema.String),
+  attachment: Schema.optional(Schema.Boolean),
+  reasoning: Schema.optional(Schema.Boolean),
+  temperature: Schema.optional(Schema.Boolean),
+  tool_call: Schema.optional(Schema.Boolean),
+  interleaved: Schema.optional(Schema.Union([
+    Schema.Boolean,
+    Schema.String,
+    Schema.Struct({
+      field: Schema.String
+    })
+  ])),
+  cost: Schema.optional(Schema.Struct({
+    input: Schema.Finite,
+    output: Schema.Finite,
+    cache_read: Schema.optional(Schema.Finite),
+    cache_write: Schema.optional(Schema.Finite),
+    context_over_200k: Schema.optional(Schema.Struct({
+      input: Schema.Finite,
+      output: Schema.Finite,
+      cache_read: Schema.optional(Schema.Finite),
+      cache_write: Schema.optional(Schema.Finite)
+    }))
+  })),
+  limit: Schema.optional(Schema.Struct({
+    context: Schema.Finite,
+    input: Schema.optional(Schema.Finite),
+    output: Schema.Finite
+  })),
+  modalities: Schema.optional(Schema.Struct({
+    input: Schema.optional(Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"])))),
+    output: Schema.optional(Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"]))))
+  })),
+  experimental: Schema.optional(Schema.Boolean),
+  status: Schema.optional(ModelStatus),
+  provider: Schema.optional(Schema.Struct({ npm: Schema.optional(Schema.String), api: Schema.optional(Schema.String) })),
+  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  variants: Schema.optional(Schema.Record(Schema.String, Schema.StructWithRest(Schema.Struct({
+    disabled: Schema.optional(Schema.Boolean).annotate({ description: "Disable this variant for the model" })
+  }), [Schema.Record(Schema.String, Schema.Any)])).annotate({ description: "Variant-specific configuration" }))
+});
+var Info = Schema.Struct({
+  api: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  env: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  id: Schema.optional(Schema.String),
+  npm: Schema.optional(Schema.String),
+  whitelist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  blacklist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  options: Schema.optional(Schema.StructWithRest(Schema.Struct({
+    apiKey: Schema.optional(Schema.String),
+    baseURL: Schema.optional(Schema.String),
+    enterpriseUrl: Schema.optional(Schema.String).annotate({
+      description: "GitHub Enterprise URL for copilot authentication"
+    }),
+    setCacheKey: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable promptCacheKey for this provider (default false)"
+    }),
+    timeout: Schema.optional(Schema.Union([PositiveInt, Schema.Literal(false)]).annotate({
+      description: "Timeout in milliseconds for full requests to this provider. Set to false to disable timeout."
+    })).annotate({
+      description: "Timeout in milliseconds for full requests to this provider. Set to false to disable timeout."
+    }),
+    headerTimeout: Schema.optional(Schema.Union([PositiveInt, Schema.Literal(false)]).annotate({
+      description: "Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout."
+    })).annotate({
+      description: "Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout."
+    }),
+    chunkTimeout: Schema.optional(PositiveInt).annotate({
+      description: "Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted."
+    })
+  }), [Schema.Record(Schema.String, Schema.Any)])),
+  models: Schema.optional(Schema.Record(Schema.String, Model))
+}).annotate({ identifier: "ProviderConfig" });
+
+export { ModelStatus, Model, Info, exports_provider };

package/dist/chunks/ripgrep-1c00jchy.js

@@ -0,0 +1,64 @@
+import {
+  collectBoundedResponseBody
+} from "./ripgrep-jve7t217.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/websearch/mcp.ts
+var exports_mcp = {};
+__export(exports_mcp, {
+  parseResponse: () => parseResponse,
+  call: () => call,
+  WebSearchMcp: () => exports_mcp,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES
+});
+import { Duration, Effect, Schema } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+var MAX_RESPONSE_BYTES = 256 * 1024;
+var parseResponse = (body, result) => {
+  const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })));
+  const parse = (payload) => {
+    const trimmed = payload.trim();
+    if (!trimmed.startsWith("{"))
+      return Effect.succeed(undefined);
+    return decode(trimmed).pipe(Effect.map((response) => response.result));
+  };
+  return Effect.gen(function* () {
+    const trimmed = body.trim();
+    const direct = trimmed ? yield* parse(trimmed) : undefined;
+    if (direct)
+      return direct;
+    for (const line of body.split(`
+`)) {
+      if (!line.startsWith("data: "))
+        continue;
+      const data = yield* parse(line.substring(6));
+      if (data)
+        return data;
+    }
+  });
+};
+var call = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
+  const request = yield* HttpClientRequest.post(url).pipe(HttpClientRequest.accept("application/json, text/event-stream"), HttpClientRequest.setHeaders(headers), HttpClientRequest.schemaBodyJson(Schema.Struct({
+    jsonrpc: Schema.Literal("2.0"),
+    id: Schema.Literal(1),
+    method: Schema.Literal("tools/call"),
+    params: Schema.Struct({ name: Schema.String, arguments: schema.input })
+  }))({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: tool, arguments: value }
+  }));
+  return yield* Effect.gen(function* () {
+    const response = yield* HttpClient.filterStatusOk(http).execute(request);
+    const body = yield* collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`));
+    return yield* parseResponse(body.toString("utf8"), schema.output);
+  }).pipe(Effect.timeoutOrElse({
+    duration: Duration.seconds(25),
+    orElse: () => Effect.fail(new Error(`${tool} request timed out`))
+  }));
+});
+
+export { MAX_RESPONSE_BYTES, parseResponse, call, exports_mcp };

package/dist/chunks/ripgrep-1cxcv3mr.js

@@ -0,0 +1,205 @@
+import {
+  exports_integration
+} from "./ripgrep-qrmb8ve0.js";
+import {
+  exports_state
+} from "./ripgrep-wt193r4g.js";
+import {
+  exports_model
+} from "./ripgrep-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/catalog.ts
+var exports_catalog = {};
+__export(exports_catalog, {
+  node: () => node,
+  Service: () => Service,
+  Event: () => Event,
+  Catalog: () => exports_catalog
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Array, Context, Effect, Layer, Order, pipe } from "effect";
+import { Catalog } from "@opencode-ai/schema/catalog";
+import { Event } from "@opencode-ai/schema/catalog";
+
+class Service extends Context.Service()("@opencode/Catalog") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const integrations = yield* exports_integration.Service;
+  const available = (provider, integration) => {
+    if (provider.activation === "disabled")
+      return false;
+    if (provider.activation === "enabled")
+      return true;
+    if (integration?.connections.length)
+      return true;
+    return provider.integrationID === undefined && !integration;
+  };
+  const projectModel = (model, provider) => {
+    return {
+      ...model,
+      package: model.package ?? provider.package,
+      settings: exports_provider.mergeOverlay(provider.settings, model.settings),
+      headers: exports_provider.mergeHeaders(provider.headers, model.headers),
+      body: exports_provider.mergeOverlay(provider.body, model.body)
+    };
+  };
+  const state = exports_state.create({
+    name: "catalog",
+    initial: () => ({ providers: new Map }),
+    draft: (draft) => {
+      const result2 = {
+        provider: {
+          list: () => Array.fromIterable(draft.providers.values()),
+          get: (providerID) => draft.providers.get(providerID),
+          update: (providerID, fn) => {
+            let current = draft.providers.get(providerID);
+            if (!current) {
+              current = {
+                provider: exports_provider.Info.empty(providerID),
+                models: new Map
+              };
+              draft.providers.set(providerID, current);
+            }
+            fn(current.provider);
+          },
+          remove: (providerID) => {
+            draft.providers.delete(providerID);
+          }
+        },
+        model: {
+          get: (providerID, modelID) => draft.providers.get(providerID)?.models.get(modelID),
+          update: (providerID, modelID, fn) => {
+            let record = draft.providers.get(providerID);
+            if (!record) {
+              record = {
+                provider: exports_provider.Info.empty(providerID),
+                models: new Map
+              };
+              draft.providers.set(providerID, record);
+            }
+            const model = record.models.get(modelID) ?? exports_model.Info.default(providerID, modelID);
+            if (!record.models.has(modelID))
+              record.models.set(modelID, model);
+            fn(model);
+            model.id = modelID;
+            model.providerID = providerID;
+          },
+          remove: (providerID, modelID) => {
+            draft.providers.get(providerID)?.models.delete(modelID);
+          },
+          default: {
+            get: () => draft.defaultModel,
+            set: (providerID, modelID) => {
+              draft.defaultModel = { providerID, modelID };
+            }
+          }
+        }
+      };
+      return result2;
+    },
+    finalize: Effect.fn("Catalog.finalize")(function* (catalog) {
+      yield* bus.publish(Catalog.Event.Updated, {});
+    })
+  });
+  const result = {
+    transform: state.transform,
+    reload: state.reload,
+    provider: {
+      get: Effect.fn("Catalog.provider.get")(function* (providerID) {
+        return state.get().providers.get(providerID)?.provider;
+      }),
+      all: Effect.fn("Catalog.provider.all")(function* () {
+        return Array.fromIterable(state.get().providers.values()).map((record) => record.provider);
+      }),
+      available: Effect.fn("Catalog.provider.available")(function* () {
+        const active = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]));
+        return (yield* result.provider.all()).filter((provider) => available(provider, active.get(provider.integrationID ?? exports_integration.ID.make(provider.id))));
+      })
+    },
+    model: {
+      get: Effect.fn("Catalog.model.get")(function* (providerID, modelID) {
+        const record = state.get().providers.get(providerID);
+        if (!record)
+          return;
+        const model = record.models.get(modelID);
+        return model && projectModel(model, record.provider);
+      }),
+      all: Effect.fn("Catalog.model.all")(function* () {
+        return pipe(Array.fromIterable(state.get().providers.values()), Array.flatMap((record) => {
+          return Array.fromIterable(record.models.values()).map((model) => projectModel(model, record.provider));
+        }), Array.sortWith((item) => item.time.released, Order.flip(Order.Number)));
+      }),
+      available: Effect.fn("Catalog.model.available")(function* () {
+        const providers = new Set((yield* result.provider.available()).map((provider) => provider.id));
+        const models = [];
+        for (const record of state.get().providers.values()) {
+          if (!providers.has(record.provider.id))
+            continue;
+          for (const model of record.models.values()) {
+            if (!model.enabled)
+              continue;
+            models.push(projectModel(model, record.provider));
+          }
+        }
+        return pipe(models, Array.sortWith((item) => item.time.released, Order.flip(Order.Number)));
+      }),
+      default: Effect.fn("Catalog.model.default")(function* () {
+        const defaultModel = state.get().defaultModel;
+        if (defaultModel) {
+          const provider = yield* result.provider.get(defaultModel.providerID);
+          if (provider && (yield* result.provider.available()).some((item) => item.id === provider.id)) {
+            const model = yield* result.model.get(defaultModel.providerID, defaultModel.modelID);
+            if (model?.enabled)
+              return model;
+          }
+        }
+        return (yield* result.model.available())[0];
+      }),
+      small: Effect.fn("Catalog.model.small")(function* (providerID) {
+        const record = state.get().providers.get(providerID);
+        if (!record)
+          return;
+        const provider = record.provider;
+        if (providerID === exports_provider.ID.azure) {
+          return;
+        }
+        if (providerID === exports_provider.ID.opencode) {
+          const gpt5Nano = record.models.get(exports_model.ID.make("gpt-5-nano"));
+          if (gpt5Nano?.enabled && gpt5Nano.status === "active")
+            return projectModel(gpt5Nano, provider);
+        }
+        const candidates = pipe(Array.fromIterable(record.models.values()), Array.filter((model) => model.providerID === providerID && model.enabled && model.status === "active" && model.capabilities.input.some((item) => item.startsWith("text")) && model.capabilities.output.some((item) => item.startsWith("text"))), Array.map((model) => ({
+          model,
+          cost: model.cost[0] ? model.cost[0].input + model.cost[0].output : 999,
+          age: (Date.now() - model.time.released) / (1000 * 60 * 60 * 24 * 30),
+          small: SMALL_MODEL_RE.test(`${model.id} ${model.family ?? ""} ${model.name}`.toLowerCase())
+        })), Array.filter((item) => item.cost > 0 && item.age <= 18));
+        const pick = (items) => {
+          if (!Array.isReadonlyArrayNonEmpty(items))
+            return;
+          const maxCost = Math.max(...items.map((item) => item.cost), 0.01);
+          const maxAge = Math.max(...items.map((item) => item.age), 0.01);
+          const selected = Array.min(items, Order.mapInput(Order.Number, (item) => item.cost / maxCost * 0.8 + item.age / maxAge * 0.2));
+          return projectModel(selected.model, provider);
+        };
+        const small = candidates.filter((item) => item.small);
+        return pick(small.length > 0 ? small : candidates);
+      })
+    }
+  };
+  return Service.of(result);
+}));
+var SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/;
+var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node, exports_integration.node] });
+
+export { Service, node, exports_catalog, Event };

package/dist/chunks/ripgrep-1fb7bmpf.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260511173437_session-metadata.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260511173437_session-metadata",
+  up(tx) {
+    return Effect.gen(function* () {
+      if ((yield* tx.all(`PRAGMA table_info(\`session\`)`)).some((column) => column.name === "metadata"))
+        return;
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`metadata\` text;`);
+    });
+  }
+};
+var _20260511173437_session_metadata_default = migration;
+
+export { _20260511173437_session_metadata_default };

package/dist/chunks/ripgrep-1hxj4hpm.js

@@ -0,0 +1,245 @@
+import {
+  MAX_STEPS_PROMPT
+} from "./ripgrep-qaarhjrp.js";
+import {
+  toLLMMessages
+} from "./ripgrep-6jtjggv5.js";
+import {
+  exports_question
+} from "./ripgrep-qknbs75a.js";
+import {
+  exports_prompt_cache_key
+} from "./ripgrep-52jzav25.js";
+import {
+  exports_model_headers
+} from "./ripgrep-1xksxgzs.js";
+import {
+  exports_model_http
+} from "./ripgrep-93qdgxxd.js";
+import {
+  exports_prompt_cache_diagnostics
+} from "./ripgrep-wd268jeg.js";
+import {
+  exports_system_prompt
+} from "./ripgrep-v80zsxnb.js";
+import {
+  exports_tool
+} from "./ripgrep-dxqw5jns.js";
+import {
+  exports_model_transport
+} from "./ripgrep-42q4drvy.js";
+import {
+  exports_hooks
+} from "./ripgrep-0dwyqmzq.js";
+import {
+  exports_app
+} from "./ripgrep-50jxp3hw.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/model-request.ts
+var exports_model_request = {};
+__export(exports_model_request, {
+  unsupportedParts: () => unsupportedParts,
+  node: () => node,
+  layer: () => layer,
+  boundImages: () => boundImages,
+  SessionModelRequest: () => exports_model_request,
+  Service: () => Service
+});
+import { LLM, Message, SystemPart } from "@opencode-ai/ai";
+import { Cause, Config, Context, Effect, Layer, Result } from "effect";
+import { makeLocationNode } from "@opencode-ai/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 declineDefect = (cause) => {
+  const decline = cause.reasons.flatMap((reason) => Cause.isDieReason(reason) && (reason.defect instanceof exports_permission.DeclinedError || reason.defect instanceof exports_question.CancelledError) ? [reason.defect] : [])[0];
+  return decline ? Result.succeed(decline) : Result.fail(cause);
+};
+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 unsupportedParts = (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 boundImages = (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 Service extends Context.Service()("@opencode/SessionModelRequest") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const hooks = yield* exports_hooks.Service;
+  const transport = yield* exports_model_transport.Service;
+  const app = yield* exports_app.Metadata;
+  const webSocket = yield* Config.boolean("OPENCODE_EXPERIMENTAL_OPENAI_RESPONSES_WEBSOCKET").pipe(Config.withDefault(false), Effect.orDie);
+  const diagnostics = yield* Config.boolean("OPENCODE_PROMPT_CACHE_DIAGNOSTICS").pipe(Config.withDefault(false), Effect.orDie);
+  const promptCacheSnapshots = diagnostics ? new Map : undefined;
+  const prepare = Effect.fn("SessionModelRequest.prepare")(function* (input) {
+    const session = input.context.session;
+    const agent = input.context.agent;
+    const resolved = input.context.model;
+    const model = resolved.model;
+    const providerMetadataKey = model.route.providerMetadataKey ?? model.provider;
+    const stepLimitReached = agent.info.steps !== undefined && input.step >= agent.info.steps;
+    const tools = input.context.tools;
+    const system = [
+      agent.info.system ? agent.info.system : exports_system_prompt.make(tools.definitions.map((tool) => tool.name)),
+      input.context.initial
+    ].filter((part) => part.length > 0).map(SystemPart.make);
+    const history = toLLMMessages(input.context.messages, resolved.ref, providerMetadataKey);
+    const messages = stepLimitReached ? [...history, Message.assistant(MAX_STEPS_PROMPT)] : history;
+    const registry = new Map(tools.definitions.map((tool) => [tool.name, tool]));
+    const given = new Map(tools.definitions.map((tool) => [{ description: tool.description, input: { ...tool.inputSchema } }, tool]));
+    const context = yield* hooks.trigger("session", "context", {
+      sessionID: session.id,
+      agent: agent.id,
+      model: resolved.ref,
+      system,
+      messages,
+      tools: Object.fromEntries(Array.from(given, ([definition, tool]) => [tool.name, definition]))
+    });
+    const hooked = new Map(Object.entries(context.tools).flatMap(([name, definition]) => {
+      const tool = given.get(definition) ?? registry.get(name);
+      if (!tool)
+        return [];
+      return [[name, { ...tool, description: definition.description, inputSchema: definition.input }]];
+    }));
+    const request = LLM.request({
+      model,
+      http: {
+        headers: exports_model_headers.make(session, app)
+      },
+      promptCacheKey: exports_prompt_cache_key.make(session.id),
+      system: context.system,
+      messages: boundImages(unsupportedParts(context.messages, resolved.capabilities)),
+      tools: Array.from(hooked, ([name, tool]) => ({ ...tool, name })),
+      toolChoice: stepLimitReached ? "none" : undefined
+    });
+    const webSocketEligible = !(yield* hooks.has("session", "http.request")) && !(yield* hooks.has("session", "http.response"));
+    const http = webSocketEligible ? undefined : exports_model_http.middleware(hooks, {
+      sessionID: session.id,
+      agent: agent.id,
+      model: resolved.ref
+    });
+    const options = {
+      ...http ? { http } : {},
+      ...webSocket && webSocketEligible && resolved.ref.providerID === exports_provider.ID.openai && model.route.id === "openai-responses" ? { webSocket: transport.bind(session.id) } : {}
+    };
+    if (promptCacheSnapshots) {
+      const current = exports_prompt_cache_diagnostics.snapshot(request);
+      const comparison = exports_prompt_cache_diagnostics.compare(promptCacheSnapshots.get(session.id), current);
+      promptCacheSnapshots.delete(session.id);
+      promptCacheSnapshots.set(session.id, current);
+      const oldest = promptCacheSnapshots.keys().next().value;
+      if (promptCacheSnapshots.size > 100 && oldest !== undefined)
+        promptCacheSnapshots.delete(oldest);
+      yield* Effect.logInfo("prompt cache prefix").pipe(Effect.annotateLogs({
+        sessionID: session.id,
+        toolCount: current.tools.length,
+        systemParts: current.system.length,
+        messageCount: current.messages.length,
+        ...comparison
+      }));
+    }
+    const executeTool = (input2) => {
+      if (stepLimitReached)
+        return new exports_tool.Error({ message: "Tools are disabled after the maximum agent steps" });
+      const tool = hooked.get(input2.call.name);
+      if (!tool && registry.has(input2.call.name))
+        return new exports_tool.Error({ message: `Tool is not available for this request: ${input2.call.name}` });
+      return tools.execute(tool ? { ...input2, call: { ...input2.call, name: tool.name } } : input2).pipe(Effect.catchCauseFilter(declineDefect, (decline) => Effect.fail(decline)));
+    };
+    return {
+      request,
+      options,
+      webSocketEligible,
+      executeTool,
+      stepLimitReached
+    };
+  });
+  return Service.of({ prepare });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_hooks.node, exports_model_transport.node, exports_app.node]
+});
+
+export { unsupportedParts, boundImages, Service, layer, node, exports_model_request };