@opencode-ai/core 0.0.0-dev-19237 → 0.0.0-dev-19270

package/dist/chunks/{file-vt4ykcc5.js → event-logger-qkdc4gh9.js}

@@ -1,50 +1,65 @@
 import {
-  Service76,
-  node81
-} from "./file-7qhv6080.js";
+  Service80,
+  node85
+} from "./event-logger-9mxqc105.js";
+import {
+  Service79,
+  node84
+} from "./event-logger-3egsw9h3.js";
 import {
   llmClient2
-} from "./file-0e0xafbb.js";
+} from "./event-logger-0e0xafbb.js";
 import {
   SessionEvent2
-} from "./file-mntxs535.js";
+} from "./event-logger-mntxs535.js";
+import {
+  provenance2,
+  compatible2,
+  isCheckpoint2,
+  encode2
+} from "./event-logger-bsxj805k.js";
+import {
+  load2
+} from "./event-logger-r1cq807p.js";
 import {
   create3
-} from "./file-kg06axw8.js";
+} from "./event-logger-kg06axw8.js";
 import {
   toLLMMessages2
-} from "./file-zbjnn3ac.js";
+} from "./event-logger-7zsp3549.js";
 import {
   baseTranscript2,
-  unsupportedParts2
-} from "./file-na3f2bx6.js";
-import {
-  isRetryable2,
-  policy2
-} from "./file-hnyf01b0.js";
+  unsupportedParts2,
+  boundImages2
+} from "./event-logger-qepd9qkj.js";
 import {
   toSessionError2
-} from "./file-5dhjvcph.js";
+} from "./event-logger-651zrabc.js";
+import {
+  policy2,
+  transient2
+} from "./event-logger-04ndcpas.js";
 import {
   estimate2
-} from "./file-h6vf3j39.js";
+} from "./event-logger-h6vf3j39.js";
 import {
   record2,
   add2
-} from "./file-tjykrgmx.js";
+} from "./event-logger-tjykrgmx.js";
 import {
   __export
-} from "./file-9rqn6x4v.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/session/compaction.ts
 var exports_compaction2 = {};
 __export(exports_compaction2, {
-  Service: () => Service6,
+  Service: () => Service11,
   SessionCompaction: () => exports_compaction2,
   buildPrompt: () => buildPrompt2,
   estimateTokens: () => estimateTokens2,
   layer: () => layer7,
-  node: () => node9,
+  node: () => node14,
+  retainUsers: () => retainUsers2,
   serializeToolContent: () => serializeToolContent2,
   truncateToolOutput: () => truncateToolOutput2
 });
@@ -108,10 +123,11 @@ var SUMMARY_RULES = `Rules:
 var SUMMARY_HEADINGS = SUMMARY_TEMPLATE.split(`
 `).filter((line) => line.startsWith("##"));
 
-class Service6 extends Context.Service()("@opencode/SessionCompaction") {
+class Service11 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 layer7 = Layer.effect(Service6, Effect.gen(function* () {
-  const bus = yield* Service76;
+var layer7 = Layer.effect(Service11, 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 layer7 = Layer.effect(Service6, 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 layer7 = Layer.effect(Service6, 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 layer7 = Layer.effect(Service6, 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 layer7 = Layer.effect(Service6, 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 layer7 = Layer.effect(Service6, 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,17 +561,20 @@ var layer7 = Layer.effect(Service6, 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 Service6.of({
+  return Service11.of({
     transform: state.transform,
     reload: state.reload,
     enabled: () => state.get().auto,
@@ -488,10 +583,10 @@ var layer7 = Layer.effect(Service6, Effect.gen(function* () {
     compactManual
   });
 }));
-var node9 = makeLocationNode({
-  service: Service6,
+var node14 = makeLocationNode({
+  service: Service11,
   layer: layer7,
-  deps: [node81, llmClient2]
+  deps: [node84, node85, llmClient2]
 });
 
-export { Service6, estimateTokens2, truncateToolOutput2, serializeToolContent2, buildPrompt2, layer7, node9, exports_compaction2 };
+export { Service11, estimateTokens2, retainUsers2, truncateToolOutput2, serializeToolContent2, buildPrompt2, layer7, node14, exports_compaction2 };

package/dist/chunks/{file-qsdy395h.js → event-logger-qsdy395h.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./file-9rqn6x4v.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/plugin/entry-observer.ts
 var exports_entry_observer = {};

package/dist/chunks/{file-k4b13ztk.js → event-logger-qwn86fs0.js}

@@ -1,27 +1,27 @@
 import {
-  Service76
-} from "./file-7qhv6080.js";
+  Service79
+} from "./event-logger-3egsw9h3.js";
 import {
-  Service40,
-  Event9
-} from "./file-jb4h4dr1.js";
+  Service69,
+  Event14
+} from "./event-logger-w803vjcr.js";
 import {
   __export
-} from "./file-9rqn6x4v.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/wellknown/plugin.ts
 var exports_plugin = {};
 __export(exports_plugin, {
-  Plugin: () => Plugin32,
+  Plugin: () => Plugin44,
   WellKnownPlugin: () => exports_plugin
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Stream } from "effect";
-var Plugin32 = define({
+var Plugin44 = define({
   id: "opencode.wellknown",
   effect: Effect.fn(function* (ctx) {
-    const bus = yield* Service76;
-    const wellknown = yield* Service40;
+    const bus = yield* Service79;
+    const wellknown = yield* Service69;
     yield* wellknown.entries().pipe(Effect.orDie);
     yield* ctx.integration.transform((editor) => {
       wellknown.snapshot().forEach((entry) => {
@@ -41,8 +41,8 @@ var Plugin32 = define({
         });
       });
     });
-    yield* bus.subscribe(Event9.Updated).pipe(Stream.runForEach(() => ctx.integration.reload()), Effect.forkScoped({ startImmediately: true }));
+    yield* bus.subscribe(Event14.Updated).pipe(Stream.runForEach(() => ctx.integration.reload()), Effect.forkScoped({ startImmediately: true }));
   })
 });
 
-export { Plugin32, exports_plugin };
+export { Plugin44, exports_plugin };

package/dist/chunks/{file-dhv13n9b.js → event-logger-qyb7zzb8.js}

@@ -1,32 +1,32 @@
 import {
   useragent2
-} from "./file-1vkgnbk5.js";
+} from "./event-logger-mgnds49j.js";
 import {
-  Service76
-} from "./file-7qhv6080.js";
+  Service79
+} from "./event-logger-3egsw9h3.js";
 import {
   OAuth3,
-  Event17
-} from "./file-3wwk5jwz.js";
+  Event20
+} from "./event-logger-ewakerm7.js";
 import {
-  ID12,
+  ID14,
   MethodID2
-} from "./file-7d289b1g.js";
+} from "./event-logger-1874dbcy.js";
 import {
   ID18,
   isAISDK2,
   packageName2,
   mergeOverlay2
-} from "./file-52bfwkce.js";
+} from "./event-logger-9019yept.js";
 import {
   iife2
-} from "./file-1kg9ymc8.js";
+} from "./event-logger-1kg9ymc8.js";
 import {
   which2
-} from "./file-qaymkmh1.js";
+} from "./event-logger-qaymkmh1.js";
 import {
   configuredSettings2
-} from "./file-339x25ws.js";
+} from "./event-logger-bt2q55qx.js";
 
 // src/plugin/provider/azure.ts
 import { Clock, Effect, Schema, Semaphore, Stream } from "effect";
@@ -59,7 +59,7 @@ var AzurePlugin2 = define({
   effect: Effect.fn(function* (ctx) {
     const configured = yield* configuredSettings2(ID18.azure);
     const processes = yield* AppProcess.Service;
-    const bus = yield* Service76;
+    const bus = yield* Service79;
     const tokens = new Map;
     const loading = Semaphore.makeUnsafe(1);
     const loaded = {};
@@ -167,7 +167,7 @@ var AzurePlugin2 = define({
       }
     });
     const reload = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
-    yield* bus.subscribe(Event17.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID12.make("azure")), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    yield* bus.subscribe(Event20.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID14.make("azure")), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
     yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
       if (evt.model.providerID !== ID18.azure)
         return;

package/dist/chunks/{file-ztxeb84j.js → event-logger-qykqfys3.js}

@@ -1,6 +1,6 @@
 import {
   packageName2
-} from "./file-52bfwkce.js";
+} from "./event-logger-9019yept.js";
 
 // src/plugin/provider/cerebras.ts
 import { Effect } from "effect";

package/dist/chunks/{file-y3cm0t0c.js → event-logger-qzmr9e0e.js}

@@ -1,13 +1,13 @@
 import {
-  ID11,
+  ID17,
   Family2
-} from "./file-9qnjdkjv.js";
+} from "./event-logger-55xejxnm.js";
 import {
-  Service38
-} from "./file-mhq5r63x.js";
+  Service67
+} from "./event-logger-k1nec7fn.js";
 import {
   foldSettings2
-} from "./file-339x25ws.js";
+} from "./event-logger-bt2q55qx.js";
 
 // src/plugin/provider/lmstudio.ts
 import { define } from "@opencode-ai/plugin/effect/plugin";
@@ -31,12 +31,12 @@ var RemoteModel = Schema.Struct({
 var Response = Schema.Struct({ models: Schema.Array(RemoteModel) });
 var discovery = new Map;
 var discoveryLock = Semaphore.makeUnsafe(1);
-function make7(origin = "http://127.0.0.1:1234", interval = "30 seconds") {
+function make4(origin = "http://127.0.0.1:1234", interval = "30 seconds") {
   return define({
     id: "opencode.provider.lmstudio",
     effect: Effect.fn(function* (ctx) {
       const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
-      const config = yield* Service38;
+      const config = yield* Service67;
       const source = { current: configured(yield* config.entries(), origin) };
       const loaded = { models: [], hash: "[]" };
       yield* ctx.integration.transform((integrations) => {
@@ -63,7 +63,7 @@ function make7(origin = "http://127.0.0.1:1234", interval = "30 seconds") {
         });
         for (const item of loaded.models) {
           catalog.model.update(providerID, item.key, (model) => {
-            model.modelID = ID11.make(item.key);
+            model.modelID = ID17.make(item.key);
             model.name = item.display_name || item.key;
             model.family = item.architecture ? Family2.make(item.architecture) : undefined;
             model.capabilities = {
@@ -125,7 +125,7 @@ function make7(origin = "http://127.0.0.1:1234", interval = "30 seconds") {
     })
   });
 }
-var LMStudioPlugin2 = make7();
+var LMStudioPlugin2 = make4();
 function configured(entries, origin) {
   const settings = foldSettings2(entries, providerID, undefined);
   const baseURL = (typeof settings?.baseURL === "string" ? settings.baseURL : `${origin.replace(/\/+$/, "")}/v1`).replace(/\/+$/, "");
@@ -142,4 +142,4 @@ function configured(entries, origin) {
   return { baseURL, apiKey, endpoint: url.toString() };
 }
 
-export { make7, LMStudioPlugin2 };
+export { make4, LMStudioPlugin2 };