@opencode-ai/core 0.0.0-dev-18308 → 0.0.0-dev-18317

package/dist/chunks/reference-nhcbdb9z.js

@@ -1,539 +0,0 @@
-import {
-  MAX_STEPS_PROMPT
-} from "./reference-qaarhjrp.js";
-import {
-  createLLMEventPublisher
-} from "./reference-9fxjt5sk.js";
-import {
-  exports_retry
-} from "./reference-0b17sr9d.js";
-import {
-  exports_prompt_cache_diagnostics
-} from "./reference-wd268jeg.js";
-import {
-  exports_context
-} from "./reference-k2sba6yj.js";
-import {
-  exports_supervisor
-} from "./reference-5s25tnxc.js";
-import {
-  exports_compaction
-} from "./reference-091m19a6.js";
-import {
-  exports_title
-} from "./reference-d9gjxq8y.js";
-import {
-  exports_usage
-} from "./reference-sw84ckhj.js";
-import {
-  exports_model_request
-} from "./reference-re7fg3x7.js";
-import {
-  exports_model_transport
-} from "./reference-d4ax61k3.js";
-import {
-  Service
-} from "./reference-cz3dkvcz.js";
-import {
-  toSessionError
-} from "./reference-gc19wh2f.js";
-import {
-  exports_inbox
-} from "./reference-084s09rb.js";
-import {
-  exports_snapshot
-} from "./reference-k2thag1n.js";
-import {
-  llmClient
-} from "./reference-k42t1tha.js";
-import {
-  exports_tool
-} from "./reference-kjhdxymv.js";
-import {
-  exports_store
-} from "./reference-y401mb5m.js";
-import {
-  StepFailedError
-} from "./reference-fb7nfzf2.js";
-import {
-  exports_instruction_state
-} from "./reference-f11jbhcb.js";
-import {
-  SessionMessage
-} from "./reference-8rpfd2h6.js";
-import {
-  SessionEvent
-} from "./reference-a83yvq99.js";
-import {
-  exports_bus
-} from "./reference-zprqy3cn.js";
-import {
-  exports_tool_output
-} from "./reference-f7q7a28y.js";
-import {
-  exports_database
-} from "./reference-chh33txw.js";
-import {
-  __export
-} from "./reference-rvfvac9x.js";
-
-// src/session/runner/llm.ts
-var exports_llm = {};
-__export(exports_llm, {
-  node: () => node,
-  SessionRunnerLLM: () => exports_llm
-});
-import {
-  LLMClient,
-  AIError,
-  InvalidProviderOutputReason,
-  LLMEvent,
-  Message,
-  isContextOverflowFailure
-} from "@opencode-ai/ai";
-import { Cause, Config, Data, Effect, Exit, Fiber, FiberMap, Layer, Option, Pull, Schedule, Stream } from "effect";
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-var CallOutcome = Data.taggedEnum();
-var isDecline = (error) => error._tag === "Permission.DeclinedError" || error._tag === "QuestionTool.CancelledError";
-var isInterruptedStream = (failure) => {
-  if (failure.reason._tag === "InvalidProviderOutput")
-    return failure.reason.classification === "incomplete-stream";
-  if (failure.reason._tag === "Transport")
-    return failure.reason.operation === "read";
-  return false;
-};
-var classifyToolExits = (settled, calls) => {
-  const exits = settled._tag === "Success" ? settled.value : [];
-  const declines = exits.flatMap((exit, index) => exit._tag === "Failure" ? exit.cause.reasons.flatMap((reason) => Cause.isFailReason(reason) && isDecline(reason.error) ? [{ call: calls[index], reason: reason.error }] : []) : []);
-  const causes = settled._tag === "Failure" ? [settled.cause] : exits.flatMap((exit) => exit._tag === "Failure" ? [exit.cause] : []);
-  const failure = causes.flatMap((cause) => {
-    if (Cause.hasInterrupts(cause))
-      return [];
-    const reasons = cause.reasons.flatMap((reason) => Cause.isFailReason(reason) ? isDecline(reason.error) ? [] : [Cause.makeDieReason(reason.error)] : [reason]);
-    return reasons.length > 0 ? [Cause.fromReasons(reasons)] : [];
-  }).at(0);
-  return {
-    interrupted: causes.some(Cause.hasInterrupts),
-    declines,
-    failure
-  };
-};
-var TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" };
-var STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" };
-var RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" };
-var CONTINUE_AFTER_INCOMPLETE_STREAM = "The previous response was interrupted. Continue from where you left off without repeating completed content.";
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const llm = yield* LLMClient.Service;
-  const store = yield* exports_store.Service;
-  const context = yield* exports_context.Service;
-  const modelRequests = yield* exports_model_request.Service;
-  const modelTransport = yield* exports_model_transport.Service;
-  const snapshots = yield* exports_snapshot.Service;
-  const db = (yield* exports_database.Service).db;
-  const compaction = yield* exports_compaction.Service;
-  const plugins = yield* exports_supervisor.Service;
-  const title = yield* exports_title.Service;
-  const toolOutput = yield* exports_tool_output.Service;
-  const diagnostics = yield* Config.boolean("OPENCODE_PROMPT_CACHE_DIAGNOSTICS").pipe(Config.withDefault(false), Effect.orDie);
-  const promptCacheSnapshots = diagnostics ? new Map : undefined;
-  const diagnosePromptCache = Effect.fn("SessionRunner.diagnosePromptCache")(function* (sessionID, request) {
-    if (!promptCacheSnapshots)
-      return;
-    const current = exports_prompt_cache_diagnostics.snapshot(request);
-    const comparison = exports_prompt_cache_diagnostics.compare(promptCacheSnapshots.get(sessionID), current);
-    promptCacheSnapshots.delete(sessionID);
-    promptCacheSnapshots.set(sessionID, 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,
-      toolCount: current.tools.length,
-      systemParts: current.system.length,
-      messageCount: current.messages.length,
-      ...comparison
-    }));
-  });
-  const titles = yield* FiberMap.make();
-  const drain = Effect.fn("SessionRunner.drain")(function* (input) {
-    let force = input.force;
-    let continuation = input.continuation;
-    const promotable = input.promotable ?? "input";
-    if (!force && !continuation && !(yield* eligible(input.sessionID, promotable)))
-      return { type: "complete" };
-    yield* plugins.flush;
-    yield* settleStaleToolCalls(input.sessionID);
-    while (true) {
-      if (yield* runPendingCompaction(input.sessionID, "input")) {
-        force = false;
-        continue;
-      }
-      if (yield* runPendingMove(input.sessionID, "input"))
-        return { type: "moved" };
-      if (!force && !continuation && !(yield* exports_inbox.has(db, input.sessionID, promotable)))
-        return { type: "complete" };
-      const result = yield* runSteps(input.sessionID, continuation, promotable);
-      if (result.type === "moved")
-        return result;
-      force = false;
-      continuation = undefined;
-    }
-  });
-  const eligible = Effect.fnUntraced(function* (sessionID, promotable) {
-    if (yield* exports_inbox.has(db, sessionID, promotable))
-      return true;
-    if (promotable === "input")
-      return false;
-    const next = yield* exports_inbox.nextPromotable(db, sessionID, "input");
-    return next?.type === "compaction" || next?.type === "move";
-  });
-  const runSteps = Effect.fn("SessionRunner.runSteps")(function* (sessionID, continuation, drainPromotable) {
-    let promotable = continuation ? "steer" : drainPromotable;
-    let step = continuation?.step ?? 1;
-    let next = continuation;
-    let first = true;
-    while (true) {
-      if (yield* runPendingCompaction(sessionID, "steer"))
-        continue;
-      if (yield* runPendingMove(sessionID, "steer"))
-        return { type: "moved", continuation: next };
-      if (!first && !next && !(yield* exports_inbox.has(db, sessionID, "steer")))
-        return { type: "complete" };
-      const result = yield* runStep(sessionID, promotable, step);
-      first = false;
-      promotable = "steer";
-      step = result.step + 1;
-      next = result.needsContinuation ? { step } : undefined;
-    }
-  });
-  const runStep = Effect.fnUntraced(function* (sessionID, promotable, step) {
-    let assistantMessageID = SessionMessage.ID.create();
-    const retry = yield* Schedule.toStepWithSleep(exports_retry.schedule(bus, sessionID, () => assistantMessageID));
-    const waitForRetry = (failure) => retry(failure).pipe(Effect.as(CallOutcome.Retry({ step: failure.step })), Pull.catchDone(() => bus.publish(SessionEvent.Step.Failed, {
-      sessionID,
-      assistantMessageID,
-      error: failure.error
-    }).pipe(Effect.andThen(Effect.fail(failure.cause)))));
-    let currentPromotable = promotable;
-    let currentStep = step;
-    let recoverOverflow = true;
-    let recoverContinuation = true;
-    while (true) {
-      const outcome = yield* callModel(sessionID, currentPromotable, currentStep, recoverOverflow, recoverContinuation, assistantMessageID).pipe(Effect.catchTag("SessionRunner.RetryableFailure", waitForRetry));
-      if (outcome._tag === "Completed")
-        return { needsContinuation: outcome.needsContinuation, step: outcome.step };
-      if (outcome._tag === "Continue") {
-        yield* retry(new exports_retry.RetryableFailure({
-          cause: outcome.cause,
-          error: outcome.error,
-          step: outcome.step
-        })).pipe(Pull.catchDone(() => Effect.fail(outcome.cause)));
-        yield* bus.publish(SessionEvent.Synthetic, {
-          sessionID,
-          text: CONTINUE_AFTER_INCOMPLETE_STREAM
-        });
-        assistantMessageID = SessionMessage.ID.create();
-      }
-      if (outcome._tag === "Restart") {
-        if (outcome.recoveredOverflow)
-          recoverOverflow = false;
-        assistantMessageID = SessionMessage.ID.create();
-      }
-      if (outcome._tag === "RecoverFull")
-        recoverContinuation = false;
-      currentPromotable = undefined;
-      currentStep = outcome.step;
-    }
-  });
-  const callModel = Effect.fn("SessionRunner.callModel")(function* (sessionID, promotable, step, recoverOverflow, recoverContinuation, assistantMessageID) {
-    const selected = yield* context.select(sessionID);
-    yield* exports_instruction_state.prepare(db, bus, selected.instructions, selected.session.id);
-    const promoted = promotable ? yield* exports_inbox.promote(db, bus, selected.session.id, promotable) : 0;
-    if (promoted > 0 && !selected.session.parentID && exports_title.isUntitled(selected.session))
-      yield* FiberMap.run(titles, sessionID, title.generate(sessionID).pipe(Effect.ignore), {
-        onlyIfMissing: true
-      });
-    const currentStep = promoted > 0 ? 1 : step;
-    const loaded = yield* context.load(selected);
-    const { session, agent } = loaded;
-    const resolved = loaded.model;
-    const compactionInput = { session, messages: loaded.messages, resolved };
-    if (compaction.required(compactionInput)) {
-      const compacted = yield* compaction.compact(compactionInput);
-      if (compacted.status === "completed")
-        return CallOutcome.Restart({ step: currentStep, recoveredOverflow: false });
-      return yield* new StepFailedError({ error: compacted.error });
-    }
-    const stepLimitReached = agent.info.steps !== undefined && currentStep >= agent.info.steps;
-    const transcript = exports_model_request.baseTranscript({
-      agent: agent.info,
-      model: resolved,
-      tools: loaded.tools,
-      initial: loaded.initial,
-      messages: loaded.messages
-    });
-    const prepared = yield* modelRequests.prepare({
-      scope: { session, agentID: agent.id, model: resolved, tools: loaded.tools },
-      transcript: {
-        system: transcript.system,
-        messages: stepLimitReached ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)] : transcript.messages
-      },
-      toolChoice: stepLimitReached ? "none" : undefined,
-      webSocket: "session"
-    });
-    yield* diagnosePromptCache(session.id, prepared.request);
-    const executeTool = (input) => {
-      if (stepLimitReached)
-        return new exports_tool.Error({ message: "Tools are disabled after the maximum agent steps" });
-      return prepared.executeTool(input);
-    };
-    const toolRuns = [];
-    const interruptTools = Effect.suspend(() => Fiber.interruptAll(toolRuns.map((run) => run.fiber)));
-    const startSnapshot = yield* snapshots.capture();
-    const publisher = createLLMEventPublisher(bus, {
-      sessionID: session.id,
-      agent: agent.id,
-      model: resolved.ref,
-      providerMetadataKey: transcript.providerMetadataKey,
-      snapshot: startSnapshot,
-      assistantMessageID
-    });
-    const stepUsage = (finish) => ({
-      cost: exports_usage.calculateCost(resolved.cost, finish.tokens),
-      tokens: finish.tokens
-    });
-    const captureStepEnd = Effect.fnUntraced(function* () {
-      const snapshot = yield* snapshots.capture();
-      const files = startSnapshot && snapshot ? startSnapshot === snapshot ? [] : yield* snapshots.files({ from: startSnapshot, to: snapshot }).pipe(Effect.orElseSucceed(() => {
-        return;
-      })) : undefined;
-      return { snapshot, files };
-    });
-    const publishStepEnd = (finish) => Effect.gen(function* () {
-      const end = yield* captureStepEnd();
-      yield* bus.publish(SessionEvent.Step.Ended, {
-        sessionID: session.id,
-        assistantMessageID: yield* publisher.startAssistant(),
-        finish: finish.finish,
-        rawFinish: finish.rawFinish,
-        providerState: finish.providerState,
-        ...stepUsage(finish),
-        ...end
-      });
-    });
-    let overflowFailure;
-    const providerStream = llm.stream(prepared.request, prepared.options).pipe(Stream.runForEach((event) => Effect.gen(function* () {
-      if (overflowFailure || publisher.hasProviderError())
-        return;
-      if (LLMEvent.is.providerError(event) && isContextOverflowFailure(event) && !publisher.record().outputStarted) {
-        overflowFailure = event;
-        return;
-      }
-      yield* publisher.publish(event);
-      if (event.type !== "tool-call" || event.providerExecuted)
-        return;
-      const assistantMessageID2 = yield* publisher.assistantMessageID(event.id);
-      toolRuns.push({
-        call: event,
-        fiber: yield* Effect.uninterruptibleMask((restore) => restore(executeTool({
-          sessionID: session.id,
-          agent: agent.id,
-          messageID: assistantMessageID2,
-          call: event,
-          progress: (update) => publisher.progress(event.id, update)
-        })).pipe(Effect.flatMap(toolOutput.truncate), Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)), Effect.catchTag("Tool.Error", (error) => publisher.failTool(event.id, toSessionError(error), error.metadata).pipe(Effect.asVoid)))).pipe(Effect.forkScoped)
-      });
-    })), Effect.ensuring(publisher.flush()));
-    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-      const stream = yield* restore(providerStream).pipe(Effect.exit);
-      const streamFailure = Option.getOrUndefined(Exit.findErrorOption(stream));
-      const streamInterrupted = stream._tag === "Failure" && Cause.hasInterrupts(stream.cause);
-      if (!overflowFailure && publisher.hasStarted())
-        yield* publisher.streamed();
-      if (streamInterrupted)
-        yield* interruptTools;
-      const joined = yield* restore(Effect.forEach(toolRuns, (run) => Fiber.await(run.fiber), { concurrency: "unbounded" })).pipe(Effect.exit);
-      if (joined._tag === "Failure")
-        yield* interruptTools;
-      const tools = classifyToolExits(joined, toolRuns.map((run) => run.call));
-      if (recoverOverflow && compaction.enabled() && !publisher.record().outputStarted && isContextOverflowFailure(overflowFailure ?? streamFailure) && (yield* restore(compaction.compact(compactionInput))).status === "completed")
-        return CallOutcome.Restart({ step: currentStep, recoveredOverflow: true });
-      if (overflowFailure)
-        yield* publisher.publish(overflowFailure);
-      const unknownFinish = stream._tag === "Success" && publisher.record().finish?.finish === "unknown" ? new AIError({
-        module: "session",
-        method: "stream",
-        reason: new InvalidProviderOutputReason({
-          classification: "incomplete-stream",
-          message: "The provider response ended with an unknown finish reason."
-        })
-      }) : undefined;
-      const llmFailure = streamFailure instanceof AIError ? streamFailure : unknownFinish;
-      const llmError = llmFailure && !publisher.record().providerFailed ? toSessionError(llmFailure) : undefined;
-      if (recoverContinuation && llmFailure?.reason._tag === "Transport" && (llmFailure.reason.recovery === "retry-full" || llmFailure.reason.recovery === "rotate-and-retry-full") && !publisher.record().outputStarted)
-        return CallOutcome.RecoverFull({ step: currentStep });
-      if (llmFailure && llmError && exports_retry.isRetryable(llmFailure) && !publisher.record().outputStarted) {
-        yield* publisher.startAssistant();
-        return yield* new exports_retry.RetryableFailure({
-          cause: llmFailure,
-          error: llmError,
-          step: currentStep
-        });
-      }
-      if (llmError)
-        yield* publisher.failAssistant(llmError);
-      for (const decline of tools.declines)
-        yield* publisher.failTool(decline.call.id, {
-          type: "aborted",
-          message: decline.reason._tag === "QuestionTool.CancelledError" ? decline.reason.message : "The user declined this tool call"
-        });
-      if (tools.declines.length > 0 || streamInterrupted || tools.interrupted) {
-        yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED);
-        yield* publisher.failAssistant(STEP_INTERRUPTED);
-      }
-      if (tools.failure !== undefined) {
-        const error = toSessionError(Cause.squash(tools.failure));
-        yield* publisher.failUnsettledTools(error);
-      }
-      if (publisher.record().providerFailed)
-        yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED);
-      if (llmError)
-        yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted");
-      if (stream._tag === "Success" && !publisher.record().providerFailed) {
-        const hostedResultMissing = yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted");
-        if (hostedResultMissing && !publisher.record().finish)
-          yield* publisher.failAssistant(RESULT_MISSING);
-      }
-      const record = publisher.record();
-      if (record.finish && !record.failure)
-        yield* publishStepEnd(record.finish);
-      if (record.failure) {
-        const end = yield* captureStepEnd();
-        yield* publisher.publishStepFailure({
-          ...record.finish ? stepUsage(record.finish) : {},
-          ...end
-        });
-      }
-      if (llmFailure && llmError && isInterruptedStream(llmFailure) && record.outputStarted && tools.declines.length === 0 && !tools.interrupted)
-        return CallOutcome.Continue({
-          cause: llmFailure,
-          error: llmError,
-          step: currentStep
-        });
-      if (stream._tag === "Failure")
-        return yield* Effect.failCause(stream.cause);
-      if (tools.declines.length > 0)
-        return yield* Effect.interrupt;
-      if (tools.interrupted && tools.failure)
-        return yield* Effect.failCause(tools.failure);
-      if (tools.interrupted && joined._tag === "Failure")
-        return yield* Effect.failCause(joined.cause);
-      if (record.failure)
-        return yield* new StepFailedError({ error: record.failure });
-      return CallOutcome.Completed({
-        needsContinuation: !stepLimitReached && record.calls.some((call) => !call.providerExecuted && (call.called || call.settled)),
-        step: currentStep
-      });
-    }));
-  }, Effect.scoped);
-  const runPendingCompaction = Effect.fn("SessionRunner.runPendingCompaction")(function* (sessionID, promotable) {
-    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-      const pending = yield* exports_inbox.serialized(sessionID, Effect.gen(function* () {
-        const selected = yield* exports_inbox.nextPromotable(db, sessionID, promotable);
-        if (selected?.type !== "compaction")
-          return;
-        yield* bus.publishAll([
-          [SessionEvent.InboxDelivered, { sessionID, inboxID: selected.id }],
-          [SessionEvent.Compaction.Started, { sessionID, reason: "manual", recent: "", inputID: selected.id }]
-        ]);
-        return selected;
-      }));
-      if (pending?.type !== "compaction")
-        return false;
-      const session = yield* getSession(sessionID);
-      const compacted = yield* restore(Effect.gen(function* () {
-        return yield* compaction.compactManual({
-          session,
-          messages: yield* store.context(sessionID),
-          inputID: pending.id,
-          started: true
-        });
-      })).pipe(Effect.exit);
-      if (Exit.isSuccess(compacted))
-        return true;
-      yield* bus.publish(SessionEvent.Compaction.Failed, {
-        sessionID,
-        reason: "manual",
-        error: Cause.hasInterruptsOnly(compacted.cause) ? { type: "aborted", message: "Compaction cancelled" } : { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
-        inputID: pending.id
-      });
-      return yield* Effect.failCause(compacted.cause);
-    }));
-  });
-  const runPendingMove = Effect.fn("SessionRunner.runPendingMove")(function* (sessionID, promotable) {
-    return yield* exports_inbox.serialized(sessionID, Effect.gen(function* () {
-      const pending = yield* exports_inbox.nextPromotable(db, sessionID, promotable);
-      if (pending?.type !== "move")
-        return false;
-      yield* modelTransport.close(sessionID);
-      yield* bus.publishAll([
-        [SessionEvent.InboxDelivered, { sessionID, inboxID: pending.id }],
-        [
-          SessionEvent.Moved,
-          {
-            sessionID,
-            location: pending.payload.location,
-            projectID: pending.payload.projectID,
-            subpath: pending.payload.subpath
-          }
-        ]
-      ]);
-      return true;
-    }));
-  });
-  const settleStaleToolCalls = Effect.fn("SessionRunner.settleStaleToolCalls")(function* (sessionID) {
-    for (const message of yield* store.context(sessionID)) {
-      if (message.type !== "assistant")
-        continue;
-      for (const tool of message.content) {
-        if (tool.type !== "tool" || tool.state.status !== "streaming" && tool.state.status !== "running")
-          continue;
-        yield* bus.publish(SessionEvent.Tool.Failed, {
-          sessionID,
-          assistantMessageID: message.id,
-          id: tool.id,
-          error: { type: "aborted", message: `Tool execution interrupted: ${tool.name}` },
-          executed: tool.executed === true
-        });
-      }
-    }
-  });
-  const getSession = Effect.fn("SessionRunner.getSession")(function* (sessionID) {
-    const session = yield* store.get(sessionID);
-    if (!session)
-      return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
-    return session;
-  });
-  return Service.of({ drain });
-}));
-var node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [
-    exports_bus.node,
-    llmClient,
-    exports_context.node,
-    exports_model_request.node,
-    exports_model_transport.node,
-    exports_store.node,
-    exports_compaction.node,
-    exports_supervisor.node,
-    exports_title.node,
-    exports_snapshot.node,
-    exports_tool_output.node,
-    exports_database.node
-  ]
-});
-
-export { node, exports_llm };

package/dist/plugin/provider/groq.js

@@ -1,8 +0,0 @@
-import {
-  GroqPlugin
-} from "../../chunks/reference-ayfwnm78.js";
-import"../../chunks/reference-0zz82cjq.js";
-import"../../chunks/reference-rvfvac9x.js";
-export {
-  GroqPlugin
-};

package/dist/types/plugin/provider/groq.d.ts

@@ -1 +0,0 @@
-export declare const GroqPlugin: import("@opencode-ai/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;