@opencode/core 0.0.0-beta-19398 → 0.0.0-beta-19419

package/dist/chunks/{location-mutation-510m7gjw.js → mime-wbkyxrgf.js}

@@ -1,15 +1,15 @@
 import {
   PositiveInt2
-} from "./location-mutation-922hggd3.js";
+} from "./mime-922hggd3.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./mime-9rqn6x4v.js";
 
 // src/v1/config/provider.ts
 var exports_provider2 = {};
 __export(exports_provider2, {
   ConfigProviderV1: () => exports_provider2,
-  Info: () => Info17,
+  Info: () => Info15,
   Model: () => Model2,
   ModelStatus: () => ModelStatus2
 });
@@ -61,7 +61,7 @@ var Model2 = 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 Info17 = Schema.Struct({
+var Info15 = Schema.Struct({
   api: Schema.optional(Schema.String),
   name: Schema.optional(Schema.String),
   env: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
@@ -95,4 +95,4 @@ var Info17 = Schema.Struct({
   models: Schema.optional(Schema.Record(Schema.String, Model2))
 }).annotate({ identifier: "ProviderConfig" });
 
-export { ModelStatus2, Model2, Info17, exports_provider2 };
+export { ModelStatus2, Model2, Info15, exports_provider2 };

package/dist/chunks/{location-mutation-wd87259q.js → mime-wd87259q.js}

@@ -1,7 +1,7 @@
 import {
   getViewSelectedFieldsRuntime2,
   orderSelectedFields2
-} from "./location-mutation-emrn6kk6.js";
+} from "./mime-emrn6kk6.js";
 
 // src/database/drizzle/sqlite-core/effect/select.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";

package/dist/chunks/{location-mutation-g63tzfz2.js → mime-wk6ejfve.js}

@@ -1,56 +1,56 @@
 import {
-  ID18,
-  Info33,
+  ID11,
+  Info24,
   SessionSchema2
-} from "./location-mutation-7wdjtyr9.js";
+} from "./mime-xxynqx5z.js";
 import {
   RelativePath2
-} from "./location-mutation-922hggd3.js";
+} from "./mime-922hggd3.js";
 import {
   Service80,
   node85
-} from "./location-mutation-m512vzfg.js";
+} from "./mime-988ynk0k.js";
 import {
   isSynced2,
-  Service77,
-  node82
-} from "./location-mutation-sedkckjb.js";
+  Service79,
+  node84
+} from "./mime-d414zwqj.js";
 import {
-  Service75,
-  node80
-} from "./location-mutation-pzpywyfj.js";
+  Service70,
+  node75
+} from "./mime-4qdk51ny.js";
 import {
-  Service44,
-  node48
-} from "./location-mutation-m46exch3.js";
+  Service40,
+  node43
+} from "./mime-qfzde7bh.js";
 import {
   SessionEvent2
-} from "./location-mutation-ec1grn59.js";
+} from "./mime-ec1grn59.js";
 import {
   SessionMessageTable2
-} from "./location-mutation-a1bz86dw.js";
+} from "./mime-a1bz86dw.js";
 import {
-  node46
-} from "./location-mutation-q9hbvwne.js";
+  node41
+} from "./mime-ph4vew0r.js";
 import {
   current2
-} from "./location-mutation-fxqygnfa.js";
+} from "./mime-3amprz0f.js";
 import {
   snapshot2
-} from "./location-mutation-yvvy1a1h.js";
+} from "./mime-h7f00xnw.js";
 import {
   Slug2
-} from "./location-mutation-gebd4c9n.js";
+} from "./mime-gebd4c9n.js";
 import {
   SessionAlreadyProjected2,
-  node27
-} from "./location-mutation-w7fytw90.js";
+  node23
+} from "./mime-dbt2jb7m.js";
 import {
   Metadata2,
-  node43
-} from "./location-mutation-ttrnch24.js";
+  node66
+} from "./mime-j1tqpjge.js";
 import {
-  NotFoundError9,
+  NotFoundError6,
   MessageNotFoundError2,
   ForkEmptyError2,
   MessageDecodeError2,
@@ -61,50 +61,50 @@ import {
   BusyError2,
   InboxConflictError2,
   SkillNotFoundError2
-} from "./location-mutation-gy8bp4n5.js";
+} from "./mime-ga6hqhxm.js";
 import {
   ListInput4,
-  Service70,
-  node75
-} from "./location-mutation-0xtb2bpj.js";
+  Service43,
+  node46
+} from "./mime-mtk5ndsr.js";
 import {
-  Service78,
-  node83
-} from "./location-mutation-cw3cq2se.js";
+  Service63,
+  node68
+} from "./mime-5rgkh6ng.js";
 import {
-  Service40,
-  node45
-} from "./location-mutation-ehntj2pc.js";
+  Service36,
+  node40
+} from "./mime-263cr94x.js";
 import {
   llmClient2
-} from "./location-mutation-5t3nmthw.js";
+} from "./mime-5t3nmthw.js";
 import {
-  Service26,
-  node31
-} from "./location-mutation-t8wk4avw.js";
+  Service29,
+  node33
+} from "./mime-caw866h7.js";
 import {
   generate3
-} from "./location-mutation-981wd75n.js";
+} from "./mime-ez804y10.js";
 import {
   execute2
-} from "./location-mutation-t768js4p.js";
+} from "./mime-etxs3v4e.js";
 import {
   DestinationNotFoundError2,
   DestinationNotDirectoryError2,
   DestinationUnavailableError2,
-  Service22,
-  node26
-} from "./location-mutation-zbqs32x3.js";
+  Service18,
+  node22
+} from "./mime-z10kvaap.js";
 import {
-  Service36,
-  node40
-} from "./location-mutation-rmdyxgmk.js";
+  Service53,
+  node56
+} from "./mime-w49382pb.js";
 import {
-  make13
-} from "./location-mutation-dk6r9dar.js";
+  make12
+} from "./mime-nrywpzpw.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./mime-9rqn6x4v.js";
 
 // src/session.ts
 var exports_session = {};
@@ -115,21 +115,21 @@ __export(exports_session, {
   DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
   DestinationNotFoundError: () => DestinationNotFoundError2,
   DestinationUnavailableError: () => DestinationUnavailableError2,
-  ID: () => ID18,
+  ID: () => ID11,
   InboxConflictError: () => InboxConflictError2,
-  Info: () => Info33,
+  Info: () => Info24,
   ListAnchor: () => ListAnchor2,
   ListInput: () => ListInput2,
   MessageDecodeError: () => MessageDecodeError2,
   MessageNotFoundError: () => MessageNotFoundError2,
-  NotFoundError: () => NotFoundError9,
+  NotFoundError: () => NotFoundError6,
   PromptConflictError: () => PromptConflictError2,
-  Service: () => Service21,
+  Service: () => Service17,
   Session: () => exports_session,
   SessionSchema: () => SessionSchema2,
   SkillNotFoundError: () => SkillNotFoundError2,
   SyntheticConflictError: () => SyntheticConflictError2,
-  node: () => node25
+  node: () => node21
 });
 import { Effect, Layer, Schema, Context, Stream } from "effect";
 import { LLMClient } from "@opencode/ai";
@@ -140,25 +140,25 @@ import path from "path";
 import { Node } from "@opencode/util/effect/app-node";
 import { FSUtil } from "@opencode/util/fs-util";
 var ListInput2 = ListInput4;
-class Service21 extends Context.Service()("@opencode/Session") {
+class Service17 extends Context.Service()("@opencode/Session") {
 }
-var layer = Layer.effect(Service21, Effect.gen(function* () {
+var layer = Layer.effect(Service17, Effect.gen(function* () {
   const app = yield* Metadata2;
   const database = yield* Service80;
   const db = database.db;
-  const bus = yield* Service77;
-  const projects = yield* Service75;
-  const execution = yield* Service40;
+  const bus = yield* Service79;
+  const projects = yield* Service70;
+  const execution = yield* Service36;
   const llm = yield* LLMClient.Service;
-  const transport = yield* Service26;
-  const store = yield* Service70;
-  const instances = yield* Service44;
-  const moves = yield* Service22;
-  const jobs = yield* Service78;
-  const environments = yield* Service36;
-  const sessions = yield* make13();
+  const transport = yield* Service29;
+  const store = yield* Service43;
+  const instances = yield* Service40;
+  const moves = yield* Service18;
+  const jobs = yield* Service63;
+  const environments = yield* Service53;
+  const sessions = yield* make12();
   const isDurableSessionEvent = Schema.is(SessionEvent2.Durable);
-  const result = Service21.of({
+  const result = Service17.of({
     create: Effect.fn("Session.create")(function* (input) {
       const sessionID = input.id ?? SessionSchema2.ID.create();
       const recorded = yield* store.get(sessionID);
@@ -166,7 +166,7 @@ var layer = Layer.effect(Service21, Effect.gen(function* () {
         return recorded;
       const parent = input.parentID ? yield* store.get(input.parentID) : undefined;
       if (input.parentID && parent === undefined)
-        return yield* new NotFoundError9({ sessionID: input.parentID });
+        return yield* new NotFoundError6({ sessionID: input.parentID });
       const location = parent?.location ?? input.location;
       if (location === undefined)
         return yield* Effect.die(new Error("Session.create requires either location or an existing parentID"));
@@ -259,11 +259,11 @@ var layer = Layer.effect(Service21, Effect.gen(function* () {
     prompt: (input) => sessions.forSession(input.sessionID).prompt(input),
     generate: Effect.fn("Session.generate")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      return yield* generate3({ session, prompt: input.prompt }).pipe(Effect.provideService(Service44, instances), Effect.provideService(Service80, database), Effect.provideService(LLMClient.Service, llm));
+      return yield* generate3({ session, prompt: input.prompt }).pipe(Effect.provideService(Service40, instances), Effect.provideService(Service80, database), Effect.provideService(LLMClient.Service, llm));
     }),
     command: Effect.fn("Session.command")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      return yield* execute2({ ...input, session }).pipe(Effect.provideService(Service44, instances));
+      return yield* execute2({ ...input, session }).pipe(Effect.provideService(Service40, instances));
     }),
     shell: (input) => sessions.forSession(input.sessionID).shell(input),
     skill: (input) => sessions.forSession(input.sessionID).skill(input),
@@ -303,26 +303,26 @@ var layer = Layer.effect(Service21, Effect.gen(function* () {
   });
   return result;
 }));
-var node25 = Node.makeGlobalNode({
-  service: Service21,
+var node21 = Node.makeGlobalNode({
+  service: Service17,
   layer,
   deps: [
-    node83,
-    node40,
+    node68,
+    node56,
     node85,
-    node82,
-    node80,
-    node45,
-    node31,
-    llmClient2,
+    node84,
     node75,
-    node48,
+    node40,
+    node33,
+    llmClient2,
     node46,
-    node26,
-    node27,
+    node43,
+    node41,
+    node22,
+    node23,
     FSUtil.node,
-    node43
+    node66
   ]
 });
 
-export { ListAnchor2, ListInput2, Service21, node25, exports_session };
+export { ListAnchor2, ListInput2, Service17, node21, exports_session };

package/dist/chunks/mime-wrph251t.js

@@ -0,0 +1,260 @@
+import {
+  Metadata2,
+  useragent2,
+  node66
+} from "./mime-j1tqpjge.js";
+import {
+  provenance2,
+  compatible2
+} from "./mime-bccb6npm.js";
+import {
+  Service69,
+  node74
+} from "./mime-9pm6y0s1.js";
+import {
+  DeclinedError2
+} from "./mime-g95z8t2a.js";
+import {
+  CancelledError2
+} from "./mime-x2xrmj38.js";
+import {
+  Error5
+} from "./mime-0bgf9fe6.js";
+import {
+  Service29,
+  node33
+} from "./mime-caw866h7.js";
+import {
+  make14
+} from "./mime-nhy5jxhy.js";
+import {
+  toLLMMessages2
+} from "./mime-t23qze4t.js";
+import {
+  __export
+} from "./mime-9rqn6x4v.js";
+
+// src/session/model-request.ts
+var exports_model_request = {};
+__export(exports_model_request, {
+  Service: () => Service28,
+  SessionModelRequest: () => exports_model_request,
+  baseTranscript: () => baseTranscript2,
+  boundImages: () => boundImages2,
+  layer: () => layer12,
+  node: () => node32,
+  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 : make14(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 Service28 extends Context.Service()("@opencode/SessionModelRequest") {
+}
+var layer12 = Layer.effect(Service28, Effect.gen(function* () {
+  const hooks = yield* Service69;
+  const transport = yield* Service29;
+  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 Error5({ 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 Service28.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 node32 = makeLocationNode({
+  service: Service28,
+  layer: layer12,
+  deps: [node74, node33, node66]
+});
+
+export { baseTranscript2, unsupportedParts2, boundImages2, Service28, layer12, node32, exports_model_request };

package/dist/chunks/{location-mutation-knva4kt0.js → mime-wy6y1t1e.js}

@@ -1,27 +1,27 @@
 import {
-  Service78
-} from "./location-mutation-cw3cq2se.js";
+  Service63
+} from "./mime-5rgkh6ng.js";
 import {
-  Service21
-} from "./location-mutation-g63tzfz2.js";
+  Service17
+} from "./mime-wk6ejfve.js";
 import {
   text2,
   deliver2
-} from "./location-mutation-x1ezjp6w.js";
+} from "./mime-x1ezjp6w.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./mime-9rqn6x4v.js";
 
 // src/session/subagent-job.ts
 var exports_subagent_job = {};
 __export(exports_subagent_job, {
   SubagentJob: () => exports_subagent_job,
-  make: () => make10
+  make: () => make9
 });
 import { Effect, Scope } from "effect";
-var make10 = Effect.gen(function* () {
-  const sessions = yield* Service21;
-  const jobs = yield* Service78;
+var make9 = Effect.gen(function* () {
+  const sessions = yield* Service17;
+  const jobs = yield* Service63;
   const scope = yield* Scope.Scope;
   const notifications = new Set;
   const notify = Effect.fn("SubagentJob.notify")(function* (recovery, startedAt) {
@@ -58,4 +58,4 @@ var make10 = Effect.gen(function* () {
   };
 });
 
-export { make10, exports_subagent_job };
+export { make9, exports_subagent_job };

package/dist/chunks/{location-mutation-x1ezjp6w.js → mime-x1ezjp6w.js}

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