@opencode-ai/core 0.0.0-dev-19236 → 0.0.0-dev-19265

package/dist/chunks/{file-k7ry919m.js → location-mutation-y375pa0k.js}

@@ -1,40 +1,54 @@
+import {
+  Service80,
+  node85
+} from "./location-mutation-gewsm2ew.js";
 import {
   Service79,
   node84
-} from "./file-swhyn6z2.js";
+} from "./location-mutation-k81hrtfb.js";
 import {
   llmClient2
-} from "./file-0e0xafbb.js";
+} from "./location-mutation-0e0xafbb.js";
 import {
   SessionEvent2
-} from "./file-mntxs535.js";
+} from "./location-mutation-mntxs535.js";
+import {
+  provenance2,
+  compatible2,
+  isCheckpoint2,
+  encode2
+} from "./location-mutation-9v90f9cc.js";
+import {
+  load2
+} from "./location-mutation-1vs8d3gz.js";
 import {
   create3
-} from "./file-kg06axw8.js";
+} from "./location-mutation-kg06axw8.js";
 import {
   toLLMMessages2
-} from "./file-zbjnn3ac.js";
+} from "./location-mutation-4nkw4gk2.js";
 import {
   baseTranscript2,
-  unsupportedParts2
-} from "./file-00pw28xp.js";
-import {
-  isRetryable2,
-  policy2
-} from "./file-bcezcar3.js";
+  unsupportedParts2,
+  boundImages2
+} from "./location-mutation-2mwhmxmk.js";
 import {
   toSessionError2
-} from "./file-303p9w1h.js";
+} from "./location-mutation-wgy2tz6n.js";
+import {
+  policy2,
+  transient2
+} from "./location-mutation-p0agm8mf.js";
 import {
   estimate2
-} from "./file-h6vf3j39.js";
+} from "./location-mutation-h6vf3j39.js";
 import {
   record2,
   add2
-} from "./file-tjykrgmx.js";
+} from "./location-mutation-tjykrgmx.js";
 import {
   __export
-} from "./file-9rqn6x4v.js";
+} from "./location-mutation-9rqn6x4v.js";
 
 // src/session/compaction.ts
 var exports_compaction2 = {};
@@ -43,8 +57,9 @@ __export(exports_compaction2, {
   SessionCompaction: () => exports_compaction2,
   buildPrompt: () => buildPrompt2,
   estimateTokens: () => estimateTokens2,
-  layer: () => layer6,
+  layer: () => layer7,
   node: () => node13,
+  retainUsers: () => retainUsers2,
   serializeToolContent: () => serializeToolContent2,
   truncateToolOutput: () => truncateToolOutput2
 });
@@ -110,8 +125,9 @@ var SUMMARY_HEADINGS = SUMMARY_TEMPLATE.split(`
 
 class Service10 extends Context.Service()("@opencode/SessionCompaction") {
 }
+var hasInputUsage = (message) => message.type === "assistant" && !message.error && message.tokens !== undefined && message.tokens.input + message.tokens.cache.read + message.tokens.cache.write > 0;
 var estimateTokens2 = (input) => {
-  const index = input.messages.findLastIndex((message) => message.type === "assistant" && !message.error && message.tokens !== undefined && message.tokens.input + message.tokens.cache.read + message.tokens.cache.write > 0);
+  const index = input.messages.findLastIndex(hasInputUsage);
   const last = input.messages[index];
   const added = unsupportedParts2(toLLMMessages2(input.messages.slice(Math.max(0, index)), input.resolved.ref), input.resolved.capabilities).filter((message) => message.role !== "assistant" || message.id !== last?.id).reduce((sum, message) => sum + message.content.reduce((sum, part) => sum + estimatePart(part), 0), 0);
   if (last?.type === "assistant" && last.tokens)
@@ -142,6 +158,19 @@ var estimatePart = (part) => {
     return part.result.value.reduce((sum, content) => sum + (content.type === "text" ? estimate2(content.text) : estimateMedia(content.mime)), 0);
   return estimate2(typeof part.result.value === "string" ? part.result.value : JSON.stringify(part.result.value) ?? "");
 };
+var retainUsers2 = (messages, model, keepTokens) => {
+  const users = boundImages2(unsupportedParts2(toLLMMessages2(messages.filter((message) => message.type === "user").map((message) => ({ ...message, skills: undefined })), model.ref), model.capabilities));
+  let tokens = 0;
+  let start = users.length;
+  for (let index = users.length - 1;index >= 0; index--) {
+    const size = users[index].content.reduce((sum, part) => sum + estimatePart(part), 0);
+    if (tokens + size > keepTokens)
+      break;
+    tokens += size;
+    start = index;
+  }
+  return users.slice(start);
+};
 var truncateToolOutput2 = (value) => {
   if (value.length <= TOOL_OUTPUT_MAX_CHARS)
     return value;
@@ -262,9 +291,10 @@ var buildPrompt2 = (update) => {
 };
 var hasSummarySection = (summary) => summary.split(`
 `).some((line) => SUMMARY_HEADINGS.includes(line.trim()));
-var layer6 = Layer.effect(Service10, Effect.gen(function* () {
+var layer7 = Layer.effect(Service10, Effect.gen(function* () {
   const bus = yield* Service79;
   const llm = yield* LLMClient.Service;
+  const db = (yield* Service80).db;
   const state = create3({
     name: "session-compaction",
     initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS }),
@@ -283,40 +313,28 @@ var layer6 = Layer.effect(Service10, Effect.gen(function* () {
     yield* bus.publish(SessionEvent2.Compaction.Failed, input);
     return { status: "failed", error: input.error };
   });
-  const execute = Effect.fn("SessionCompaction.execute")(function* (input) {
+  const started = (input, recent) => input.started ? Effect.void : bus.publish(SessionEvent2.Compaction.Started, {
+    sessionID: input.context.session.id,
+    reason: input.reason,
+    recent,
+    inputID: input.inputID
+  });
+  const interrupted = (input) => input.reason === "auto" ? failed({
+    sessionID: input.context.session.id,
+    reason: input.reason,
+    inputID: input.inputID,
+    error: { type: "compaction.interrupted", message: "Compaction was interrupted" }
+  }).pipe(Effect.asVoid) : Effect.void;
+  const compactionRequest = (input, messages, prompt, webSocket) => {
     const context = input.context;
-    const history = splitHistory(context.messages, state.get().tokens);
-    if (!history)
-      return yield* failed({
-        sessionID: context.session.id,
-        reason: input.reason,
-        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-        inputID: input.inputID
-      });
-    if (!input.started)
-      yield* bus.publish(SessionEvent2.Compaction.Started, {
-        sessionID: context.session.id,
-        reason: input.reason,
-        recent: history.recent,
-        inputID: input.inputID
-      });
-    const chunks = [];
-    let failure;
-    let usage;
-    let providerState;
-    const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent2.UsageRecorded, {
-      sessionID: context.session.id,
-      source: "compaction",
-      ...usage
-    }) : Effect.void);
     const transcript = baseTranscript2({
       agent: context.agent.info,
       model: context.model,
       tools: context.tools,
       initial: context.initial,
-      messages: history.messages
+      messages
     });
-    const prepared = yield* input.prepare({
+    return input.prepare({
       kind: "compaction",
       scope: {
         session: context.session,
@@ -330,11 +348,96 @@ var layer6 = Layer.effect(Service10, Effect.gen(function* () {
         messages: [
           ...transcript.messages,
           ...input.instructionUpdate ? [Message.system(input.instructionUpdate)] : [],
-          Message.user(buildPrompt2(history.messages.some((message) => message.type === "compaction" && message.status === "completed")))
+          ...prompt
         ]
-      }
+      },
+      webSocket
+    });
+  };
+  const original = (sessionID) => load2(db, sessionID, "local").pipe(Effect.orDie);
+  const recoverLocally = (input) => original(input.context.session.id).pipe(Effect.flatMap((messages) => execute({ ...input, context: { ...input.context, messages } })));
+  const executeProvider = Effect.fn("SessionCompaction.executeProvider")(function* (input) {
+    const context = input.context;
+    const reject = (message) => failed({
+      sessionID: context.session.id,
+      reason: input.reason,
+      inputID: input.inputID,
+      error: { type: "provider.unsupported-operation", message }
+    });
+    const prepared = yield* compactionRequest(input, context.messages, [], "session");
+    const request = prepared.request;
+    const provenance = provenance2(context.model);
+    if (!provenance)
+      return yield* reject("Provider compaction requires a stable, configured endpoint");
+    if (!compatible2(provenance, provenance2({ model: request.model, ref: context.model.ref })))
+      return yield* reject("Provider compaction requires the endpoint in provider/model settings, not a model.request rewrite");
+    const transient = transient2(yield* policy2(context.session.id), {
+      agent: Agent.ID.make("compaction"),
+      model: context.model.ref,
+      hook: prepared.retry
+    });
+    yield* started(input, "");
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const result = yield* restore(Effect.gen(function* () {
+        if (LLMClient.canCompact(request, { mechanism: "trigger" })) {
+          const retained = retainUsers2(yield* original(context.session.id), context.model, state.get().tokens);
+          const result = yield* llm.compact(request, { ...prepared.options, mechanism: "trigger" }).pipe(transient);
+          return { replacement: [...retained, Message.assistant(result.checkpoint)], usage: result.usage };
+        }
+        if (LLMClient.canCompact(request))
+          return yield* llm.compact(request, { mechanism: "endpoint", http: prepared.options.http }).pipe(transient);
+        return yield* Effect.die(new Error(`${request.model.provider}/${request.model.route.id} has no compaction operation`));
+      }));
+      if (result.usage)
+        yield* bus.publish(SessionEvent2.UsageRecorded, {
+          sessionID: context.session.id,
+          source: "compaction",
+          ...record2(result.usage, context.model.cost)
+        });
+      yield* bus.publish(SessionEvent2.Compaction.Ended, {
+        sessionID: context.session.id,
+        reason: input.reason,
+        model: context.model.ref,
+        text: "",
+        recent: "",
+        providerContext: encode2(provenance, result.replacement)
+      });
+      return { status: "completed" };
+    })).pipe(Effect.onInterrupt(() => interrupted(input)), Effect.catchTag("AI.Error", (cause) => input.reason === "auto" && isContextOverflowFailure(cause) ? recoverLocally({ ...input, started: true }).pipe(Effect.map((result) => result.status === "completed" ? { ...result, recoveredOverflow: true } : result)) : failed({
+      sessionID: context.session.id,
+      reason: input.reason,
+      inputID: input.inputID,
+      error: toSessionError2(cause)
+    })));
+  });
+  const execute = Effect.fn("SessionCompaction.execute")(function* (input) {
+    const context = input.context;
+    const history = splitHistory(context.messages, state.get().tokens);
+    if (!history)
+      return yield* failed({
+        sessionID: context.session.id,
+        reason: input.reason,
+        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
+        inputID: input.inputID
+      });
+    yield* started(input, history.recent);
+    const chunks = [];
+    let failure;
+    let usage;
+    let providerState;
+    const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent2.UsageRecorded, {
+      sessionID: context.session.id,
+      source: "compaction",
+      ...usage
+    }) : Effect.void);
+    const prepared = yield* compactionRequest(input, history.messages, [
+      Message.user(buildPrompt2(history.messages.some((message) => message.type === "compaction" && message.status === "completed")))
+    ]);
+    const transient = transient2(yield* policy2(context.session.id), {
+      agent: Agent.ID.make("compaction"),
+      model: context.model.ref,
+      hook: prepared.retry
     });
-    const retry = yield* policy2(context.session.id);
     for (const request of [
       prepared.request,
       LLMRequest.update(prepared.request, {
@@ -386,31 +489,9 @@ var layer6 = Layer.effect(Service10, Effect.gen(function* () {
             return Effect.fail(new AIError({ reason: new UnknownProviderError({ message: "Compaction generation failed" }) }));
         }
         return Effect.void;
-      }), Effect.retry({
-        while: (cause) => Effect.gen(function* () {
-          if (isContextOverflowFailure(cause))
-            return false;
-          const decision = yield* retry({
-            cause,
-            error: toSessionError2(cause),
-            agent: Agent.ID.make("compaction"),
-            model: context.model.ref,
-            hook: prepared.retry,
-            retry: isRetryable2(cause)
-          });
-          if (!decision.retry)
-            return false;
-          yield* Effect.sleep(decision.delay);
-          return true;
-        })
-      }), Effect.catchTag("AI.Error", (error) => Effect.sync(() => {
+      }), transient, Effect.catchTag("AI.Error", (error) => Effect.sync(() => {
         failure = toSessionError2(error);
-      })), Effect.onInterrupt(() => recordUsage.pipe(Effect.andThen(input.reason === "auto" ? failed({
-        sessionID: context.session.id,
-        reason: input.reason,
-        error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
-        inputID: input.inputID
-      }).pipe(Effect.asVoid) : Effect.void))));
+      })), Effect.onInterrupt(() => recordUsage.pipe(Effect.andThen(interrupted(input)))));
       if (failure || hasSummarySection(chunks.join("")))
         break;
     }
@@ -438,7 +519,14 @@ var layer6 = Layer.effect(Service10, Effect.gen(function* () {
     });
     return { status: "completed" };
   });
-  const compact = (input) => execute({ ...input, reason: "auto" });
+  const compact = Effect.fn("SessionCompaction.compact")(function* (input) {
+    const request = { ...input, reason: "auto" };
+    if (input.overflow)
+      return yield* recoverLocally(request);
+    if (input.context.model.compaction?.mode !== "provider")
+      return yield* execute(request);
+    return yield* executeProvider(request);
+  });
   const required = (input) => {
     const config = state.get();
     if (!config.auto)
@@ -446,13 +534,17 @@ var layer6 = Layer.effect(Service10, Effect.gen(function* () {
     const last = input.messages.at(-1);
     if (last?.type === "compaction" && last.status === "completed")
       return false;
+    if (input.messages.findLastIndex(hasInputUsage) < input.messages.findLastIndex(isCheckpoint2))
+      return false;
     const limit = input.resolved.limit;
     const context = limit.context;
     if (context <= 0)
       return false;
     const output = Math.min(limit.output, OUTPUT_TOKEN_MAX);
     const promptCeiling = Math.min(limit.input === undefined ? Number.POSITIVE_INFINITY : limit.input - config.buffer, context - Math.max(output, config.buffer));
-    return estimateTokens2(input) >= promptCeiling;
+    const policy = input.resolved.compaction;
+    const threshold = policy?.mode === "provider" && policy.threshold !== undefined ? Math.min(policy.threshold, promptCeiling) : promptCeiling;
+    return estimateTokens2(input) >= threshold;
   };
   const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input) {
     if (findTailStart(input.messages, state.get().tokens) === undefined)
@@ -469,14 +561,17 @@ var layer6 = Layer.effect(Service10, Effect.gen(function* () {
         error: toSessionError2(cause),
         inputID: input.inputID
       }),
-      onSuccess: (context) => execute({
-        context,
-        instructionUpdate: context.instructionUpdate,
-        prepare: input.prepare,
-        reason: "manual",
-        inputID: input.inputID,
-        started: input.started
-      })
+      onSuccess: (context) => {
+        const request = {
+          context,
+          instructionUpdate: context.instructionUpdate,
+          prepare: input.prepare,
+          reason: "manual",
+          inputID: input.inputID,
+          started: input.started
+        };
+        return context.model.compaction?.mode === "provider" ? executeProvider(request) : execute(request);
+      }
     }));
   });
   return Service10.of({
@@ -490,8 +585,8 @@ var layer6 = Layer.effect(Service10, Effect.gen(function* () {
 }));
 var node13 = makeLocationNode({
   service: Service10,
-  layer: layer6,
-  deps: [node84, llmClient2]
+  layer: layer7,
+  deps: [node84, node85, llmClient2]
 });
 
-export { Service10, estimateTokens2, truncateToolOutput2, serializeToolContent2, buildPrompt2, layer6, node13, exports_compaction2 };
+export { Service10, estimateTokens2, retainUsers2, truncateToolOutput2, serializeToolContent2, buildPrompt2, layer7, node13, exports_compaction2 };

package/dist/chunks/{file-q06n7zjg.js → location-mutation-y57q34f9.js}

@@ -1,19 +1,19 @@
 import {
   fromPromise2
-} from "./file-b9wsbatv.js";
+} from "./location-mutation-b9wsbatv.js";
 import {
-  Service67
-} from "./file-cek9jpa8.js";
+  Service72
+} from "./location-mutation-kd9jwy8m.js";
 import {
   __export
-} from "./file-9rqn6x4v.js";
+} from "./location-mutation-9rqn6x4v.js";
 
 // src/plugin/module.ts
 var exports_module = {};
 __export(exports_module, {
   LoadError: () => LoadError2,
   PluginModule: () => exports_module,
-  make: () => make3
+  make: () => make7
 });
 import { Host } from "@opencode-ai/plugin/host";
 import { createPluginSources } from "@opencode-ai/plugin/source";
@@ -22,8 +22,8 @@ import { Deferred, Effect, FiberSet, PubSub, Schema, Stream } from "effect";
 import path from "path";
 import { stat } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "url";
-var make3 = Effect.fn("PluginModule.make")(function* () {
-  const watcher = yield* Service67;
+var make7 = Effect.fn("PluginModule.make")(function* () {
+  const watcher = yield* Service72;
   const scope = yield* Effect.scope;
   const runPromise = yield* FiberSet.makeRuntimePromise();
   const changes = yield* PubSub.unbounded();
@@ -102,4 +102,4 @@ var load = Effect.fn("PluginModule.load")(function* (operation, sources, options
   };
 });
 
-export { make3, LoadError2, exports_module };
+export { make7, LoadError2, exports_module };

package/dist/chunks/{file-nxrz604p.js → location-mutation-ycv9gdpt.js}

@@ -1,30 +1,30 @@
 import {
   makeUnsafe2
-} from "./file-y71avatq.js";
+} from "./location-mutation-dpkg50ah.js";
 import {
   __export
-} from "./file-9rqn6x4v.js";
+} from "./location-mutation-9rqn6x4v.js";
 
 // src/plugin/update.ts
 var exports_update = {};
 __export(exports_update, {
   PluginUpdate: () => exports_update,
-  Service: () => Service4,
-  node: () => node6
+  Service: () => Service5,
+  node: () => node8
 });
 import { Clock, Context, Effect, Exit, Layer, Option, PubSub, Stream } from "effect";
 import { Npm } from "@opencode-ai/util/npm";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 var interval = 24 * 60 * 60 * 1000;
 
-class Service4 extends Context.Service()("@opencode/PluginUpdate") {
+class Service5 extends Context.Service()("@opencode/PluginUpdate") {
 }
-var layer = Layer.effect(Service4, Effect.gen(function* () {
+var layer = Layer.effect(Service5, Effect.gen(function* () {
   const npm = yield* Npm.Service;
   const locks = makeUnsafe2();
   const status = new Map;
   const changes = yield* PubSub.unbounded();
-  return Service4.of({
+  return Service5.of({
     check: (target, options) => locks.withLock(target)(Effect.gen(function* () {
       const checkedAt = yield* Clock.currentTimeMillis;
       const current = status.get(target);
@@ -49,6 +49,6 @@ var layer = Layer.effect(Service4, Effect.gen(function* () {
     changes: () => Stream.fromPubSub(changes)
   });
 }));
-var node6 = makeGlobalNode({ service: Service4, layer, deps: [Npm.node] });
+var node8 = makeGlobalNode({ service: Service5, layer, deps: [Npm.node] });
 
-export { Service4, node6, exports_update };
+export { Service5, node8, exports_update };

package/dist/chunks/{file-2gtf4gxt.js → location-mutation-yd30tg6k.js}

@@ -1,12 +1,12 @@
 import {
   SessionMessage2
-} from "./file-982e01ww.js";
+} from "./location-mutation-982e01ww.js";
 import {
   SessionSchema2
-} from "./file-3s2nsa7k.js";
+} from "./location-mutation-wkjngxy5.js";
 import {
   __export
-} from "./file-9rqn6x4v.js";
+} from "./location-mutation-9rqn6x4v.js";
 
 // src/session/error.ts
 var exports_error = {};
@@ -22,7 +22,7 @@ __export(exports_error, {
   MessageNotAssistantError: () => MessageNotAssistantError2,
   MessageNotFoundError: () => MessageNotFoundError2,
   MessageToolIncompleteError: () => MessageToolIncompleteError2,
-  NotFoundError: () => NotFoundError7,
+  NotFoundError: () => NotFoundError9,
   PromptConflictError: () => PromptConflictError2,
   SessionErrors: () => exports_error,
   SkillNotFoundError: () => SkillNotFoundError2,
@@ -35,7 +35,7 @@ import { Agent } from "@opencode-ai/schema/agent";
 import { Skill } from "@opencode-ai/schema/skill";
 import { SessionError } from "@opencode-ai/schema/session-error";
 
-class NotFoundError7 extends Schema.TaggedError()("Session.NotFoundError", {
+class NotFoundError9 extends Schema.TaggedError()("Session.NotFoundError", {
   sessionID: SessionSchema2.ID
 }) {
 }
@@ -144,4 +144,4 @@ class SkillNotFoundError2 extends Schema.TaggedError()("Session.SkillNotFoundErr
 }) {
 }
 
-export { NotFoundError7, MessageNotFoundError2, MessageNotAssistantError2, MessageIncompleteError2, MessageToolIncompleteError2, ForkEmptyError2, MessageDecodeError2, AgentNotFoundError2, StepFailedError2, UserInterruptedError2, PromptConflictError2, SyntheticConflictError2, AttachmentError2, CompactionConflictError2, BusyError2, InboxConflictError2, SkillNotFoundError2, exports_error };
+export { NotFoundError9, MessageNotFoundError2, MessageNotAssistantError2, MessageIncompleteError2, MessageToolIncompleteError2, ForkEmptyError2, MessageDecodeError2, AgentNotFoundError2, StepFailedError2, UserInterruptedError2, PromptConflictError2, SyntheticConflictError2, AttachmentError2, CompactionConflictError2, BusyError2, InboxConflictError2, SkillNotFoundError2, exports_error };

package/dist/chunks/{file-yg7sb877.js → location-mutation-yg7sb877.js}

@@ -1,9 +1,9 @@
 import {
   absoluteColumn2
-} from "./file-r8dhm0tv.js";
+} from "./location-mutation-r8dhm0tv.js";
 import {
   ProjectTable2
-} from "./file-qvbcabdc.js";
+} from "./location-mutation-qvbcabdc.js";
 
 // src/worktree/sql.ts
 import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";

package/dist/chunks/{file-yp2x3t23.js → location-mutation-yp2x3t23.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./file-9rqn6x4v.js";
+} from "./location-mutation-9rqn6x4v.js";
 
 // src/session/run-coordinator.ts
 var exports_run_coordinator = {};