@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-ghjjbadh.js

@@ -0,0 +1,134 @@
+import {
+  AlibabaPlugin2
+} from "./aisdk-native-71q4at8m.js";
+import {
+  AmazonBedrockPlugin2
+} from "./aisdk-native-0artwwxx.js";
+import {
+  AzurePlugin2
+} from "./aisdk-native-1jdcek6j.js";
+import {
+  CerebrasPlugin2
+} from "./aisdk-native-wavq5vqb.js";
+import {
+  CloudflareAIGatewayPlugin2
+} from "./aisdk-native-vhbgy75s.js";
+import {
+  CloudflareWorkersAIPlugin2
+} from "./aisdk-native-btm2ep20.js";
+import {
+  CoherePlugin2
+} from "./aisdk-native-z0bkrqjs.js";
+import {
+  DigitalOceanPlugin2
+} from "./aisdk-native-whczfbjh.js";
+import {
+  DynamicProviderPlugin2
+} from "./aisdk-native-vzcthcp8.js";
+import {
+  GatewayPlugin2
+} from "./aisdk-native-669tq793.js";
+import {
+  GithubCopilotPlugin2
+} from "./aisdk-native-q5az2q1p.js";
+import {
+  GitLabPlugin2
+} from "./aisdk-native-vcmavarf.js";
+import {
+  GoogleVertexPlugin2
+} from "./aisdk-native-0pb75hch.js";
+import {
+  KiloPlugin2
+} from "./aisdk-native-265kqrgy.js";
+import {
+  LLMGatewayPlugin2
+} from "./aisdk-native-rga4dawr.js";
+import {
+  LMStudioPlugin2
+} from "./aisdk-native-v9kga7nj.js";
+import {
+  ModalPlugin2
+} from "./aisdk-native-qh3awkqg.js";
+import {
+  NvidiaPlugin2
+} from "./aisdk-native-70d2s7af.js";
+import {
+  OllamaPlugin2
+} from "./aisdk-native-g5eyeasx.js";
+import {
+  OpenAIPlugin3
+} from "./aisdk-native-n88zggmf.js";
+import {
+  SnowflakeCortexPlugin2
+} from "./aisdk-native-y9f55719.js";
+import {
+  OpenAICompatiblePlugin2
+} from "./aisdk-native-hrnqkpcd.js";
+import {
+  OpencodePlugin2
+} from "./aisdk-native-ajy029q4.js";
+import {
+  OpenRouterPlugin2
+} from "./aisdk-native-b5vcnazb.js";
+import {
+  PerplexityPlugin2
+} from "./aisdk-native-veqvce7d.js";
+import {
+  PoePlugin2
+} from "./aisdk-native-15rsv8cs.js";
+import {
+  SapAICorePlugin2
+} from "./aisdk-native-219neeqh.js";
+import {
+  VercelPlugin2
+} from "./aisdk-native-mz6ae2yf.js";
+import {
+  VenicePlugin2
+} from "./aisdk-native-yrhqyw5v.js";
+import {
+  VLLMPlugin2
+} from "./aisdk-native-hj31wtn3.js";
+import {
+  XAIPlugin2
+} from "./aisdk-native-qfw56etf.js";
+import {
+  ZenmuxPlugin2
+} from "./aisdk-native-cvtmmhw6.js";
+
+// src/plugin/provider.ts
+var ProviderPlugins2 = [
+  AlibabaPlugin2,
+  AmazonBedrockPlugin2,
+  AzurePlugin2,
+  CerebrasPlugin2,
+  CloudflareAIGatewayPlugin2,
+  CloudflareWorkersAIPlugin2,
+  CoherePlugin2,
+  DigitalOceanPlugin2,
+  GatewayPlugin2,
+  GithubCopilotPlugin2,
+  GitLabPlugin2,
+  GoogleVertexPlugin2,
+  KiloPlugin2,
+  LLMGatewayPlugin2,
+  LMStudioPlugin2,
+  ModalPlugin2,
+  NvidiaPlugin2,
+  OllamaPlugin2,
+  OpencodePlugin2,
+  SnowflakeCortexPlugin2,
+  OpenAICompatiblePlugin2,
+  OpenAIPlugin3,
+  OpenRouterPlugin2,
+  PerplexityPlugin2,
+  PoePlugin2,
+  SapAICorePlugin2,
+  VercelPlugin2,
+  VenicePlugin2,
+  VLLMPlugin2,
+  XAIPlugin2,
+  ZenmuxPlugin2,
+  DynamicProviderPlugin2
+];
+
+export { ProviderPlugins2 };

package/dist/chunks/aisdk-native-h03wrkyp.js

@@ -0,0 +1,492 @@
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  tokens2
+} from "./aisdk-native-tdstcens.js";
+
+// src/session/runner/publish-llm-event.ts
+import { Effect, Fiber, Iterable } from "effect";
+import { isReadonlyArrayNonEmpty } from "effect/Array";
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : { value };
+var stringify = (value) => {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var hostedContent = (result) => {
+  if (result.type === "content" && isReadonlyArrayNonEmpty(result.value))
+    return result.value;
+  return [{ type: "text", text: stringify(result.value) }];
+};
+var createLLMEventPublisher2 = (bus, input) => {
+  const deltaBatchInterval = 100;
+  const tools = new Map;
+  const failureSnapshot = (tool, metadata) => {
+    if (tool.progress === undefined)
+      return metadata === undefined ? {} : { metadata };
+    if (metadata === undefined)
+      return { metadata: tool.progress };
+    return { metadata: { ...tool.progress, ...metadata } };
+  };
+  const assistantMessageID = input.assistantMessageID;
+  let stepStarted = false;
+  let providerFailed = false;
+  let outputStarted = false;
+  let stepFailure;
+  let stepSettlement;
+  const startAssistant = Effect.fnUntraced(function* () {
+    if (stepStarted)
+      return assistantMessageID;
+    stepStarted = true;
+    yield* bus.publish(SessionEvent2.Step.Started, {
+      sessionID: input.sessionID,
+      agent: input.agent,
+      model: input.model,
+      assistantMessageID,
+      snapshot: input.snapshot
+    });
+    return assistantMessageID;
+  });
+  const currentAssistantMessageID = () => stepStarted ? Effect.succeed(assistantMessageID) : Effect.die(new Error("Tool event before assistant step start"));
+  const streamed = Effect.fnUntraced(function* () {
+    yield* bus.publish(SessionEvent2.Step.Streamed, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* startAssistant()
+    });
+  });
+  const providerState = (metadata) => metadata?.[input.providerMetadataKey];
+  const fragments = (name, ended, delta, single = false) => {
+    const chunks = new Map;
+    let nextOrdinal = 0;
+    const start = (id, state) => Effect.suspend(() => {
+      if (chunks.has(id))
+        return Effect.die(new Error(`Duplicate ${name} start: ${id}`));
+      if (single && chunks.size > 0)
+        return Effect.die(new Error(`${name} start before end: ${id}`));
+      const ordinal = nextOrdinal++;
+      chunks.set(id, { ordinal, values: [], pending: "", state });
+      return Effect.succeed(ordinal);
+    });
+    const publishDelta = Effect.fnUntraced(function* (id) {
+      if (!delta)
+        return;
+      const current = chunks.get(id);
+      if (!current)
+        return yield* Effect.die(new Error(`${name} delta before start: ${id}`));
+      if (!current.pending)
+        return;
+      const value = current.pending;
+      current.pending = "";
+      yield* delta(id, value, current.ordinal);
+      return;
+    }, Effect.uninterruptible);
+    const append = Effect.fnUntraced(function* (id, value, state) {
+      const current = chunks.get(id);
+      if (!current)
+        return yield* Effect.die(new Error(`${name} delta before start: ${id}`));
+      current.values.push(value);
+      if (delta)
+        current.pending += value;
+      if (state !== undefined)
+        current.state = { ...current.state, ...state };
+      if (current.pending && !current.timer) {
+        current.timer = yield* Effect.gen(function* () {
+          while (current.pending) {
+            yield* Effect.sleep(deltaBatchInterval);
+            yield* publishDelta(id);
+          }
+        }).pipe(Effect.ensuring(Effect.sync(() => {
+          current.timer = undefined;
+        })), Effect.forkChild({ startImmediately: true }));
+      }
+      return current.ordinal;
+    });
+    const end = Effect.fnUntraced(function* (id, state, value) {
+      const current = chunks.get(id);
+      if (!current)
+        return yield* Effect.die(new Error(`${name} end before start: ${id}`));
+      if (current.timer)
+        yield* Fiber.interrupt(current.timer);
+      yield* publishDelta(id);
+      yield* ended(id, value ?? current.values.join(""), current.ordinal, state === undefined ? current.state : { ...current.state, ...state });
+      chunks.delete(id);
+      return;
+    });
+    const flush = Effect.fnUntraced(function* () {
+      for (const id of Array.from(chunks.keys()))
+        yield* end(id);
+    });
+    return { start, append, end, flush, has: (id) => chunks.has(id) };
+  };
+  const text = fragments("text", (_textID, value, ordinal, state) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent2.Text.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      text: value,
+      state
+    });
+  }), (_textID, value, ordinal) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent2.Text.Delta, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      delta: value
+    });
+  }), true);
+  const reasoning = fragments("reasoning", (_reasoningID, value, ordinal, state) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent2.Reasoning.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      text: value,
+      state
+    });
+  }), (_reasoningID, value, ordinal) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent2.Reasoning.Delta, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      delta: value
+    });
+  }), true);
+  const toolInput = fragments("tool input", (id, value) => Effect.gen(function* () {
+    const tool = tools.get(id);
+    if (!tool)
+      return yield* Effect.die(new Error(`Tool input end before start: ${id}`));
+    yield* bus.publish(SessionEvent2.Tool.Input.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID,
+      id,
+      text: value
+    });
+  }));
+  const flushFragments = Effect.fnUntraced(function* () {
+    yield* text.flush();
+    yield* reasoning.flush();
+    yield* toolInput.flush();
+  });
+  const startToolInput = Effect.fnUntraced(function* (event) {
+    if (tools.has(event.id))
+      return yield* Effect.die(new Error(`Duplicate tool input start: ${event.id}`));
+    yield* startAssistant();
+    const tool = {
+      name: event.name,
+      called: false,
+      settled: false,
+      providerExecuted: event.providerExecuted === true
+    };
+    tools.set(event.id, tool);
+    yield* toolInput.start(event.id);
+    yield* bus.publish(SessionEvent2.Tool.Input.Started, {
+      sessionID: input.sessionID,
+      assistantMessageID,
+      id: event.id,
+      name: event.name
+    });
+    return tool;
+  });
+  const endToolInput = Effect.fnUntraced(function* (event, value) {
+    const tool = tools.get(event.id);
+    if (!tool)
+      return yield* Effect.die(new Error(`Tool input end before start: ${event.id}`));
+    if (tool.name !== event.name)
+      return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+    if (!toolInput.has(event.id))
+      return yield* Effect.die(new Error(`Duplicate tool input end: ${event.id}`));
+    yield* toolInput.end(event.id, undefined, value);
+  });
+  const failMalformedToolInput = Effect.fnUntraced(function* (event) {
+    const tool = tools.get(event.id) ?? (yield* startToolInput(event));
+    if (tool.called || tool.settled)
+      return yield* Effect.die(new Error(`Malformed tool input after call settlement: ${event.id}`));
+    if (tool.name !== event.name)
+      return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+    if (toolInput.has(event.id))
+      yield* endToolInput(event, event.raw);
+    tool.settled = true;
+    yield* bus.publish(SessionEvent2.Tool.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID,
+      id: event.id,
+      error: {
+        type: "tool.input-json",
+        message: "Tool call arguments were malformed JSON and were not executed. Retry with valid JSON."
+      },
+      ...failureSnapshot(tool),
+      executed: false
+    });
+  });
+  const flush = Effect.fn("SessionRunner.flush")(flushFragments);
+  const failTool = Effect.fnUntraced(function* (id, error, metadata) {
+    const tool = tools.get(id);
+    if (!tool || tool.settled)
+      return false;
+    tool.settled = true;
+    yield* bus.publish(SessionEvent2.Tool.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID,
+      id,
+      error: tool.name === "subagent" && error.type === "aborted" && typeof tool.progress?.sessionID === "string" ? { ...error, message: `${error.message} (sessionID: ${tool.progress.sessionID})` } : error,
+      ...failureSnapshot(tool, metadata),
+      executed: tool.providerExecuted
+    });
+    return true;
+  });
+  const failTools = Effect.fnUntraced(function* (error, mode) {
+    let failed = false;
+    for (const [id, tool] of tools) {
+      if (tool.settled || mode === "hosted" && !tool.providerExecuted || mode === "uncalled" && tool.called)
+        continue;
+      failed = (yield* failTool(id, error)) || failed;
+    }
+    return failed;
+  });
+  const failAssistant = Effect.fnUntraced(function* (error) {
+    yield* flush();
+    yield* failTools(error, "uncalled");
+    yield* startAssistant();
+    if (stepFailure === undefined)
+      stepFailure = error;
+  });
+  const publishStepFailure = Effect.fnUntraced(function* (details) {
+    if (stepFailure === undefined)
+      return;
+    const assistantMessageID = yield* startAssistant();
+    yield* bus.publish(SessionEvent2.Step.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID,
+      error: stepFailure,
+      finish: stepSettlement?.finish === "content-filter" ? stepSettlement.finish : undefined,
+      rawFinish: stepSettlement?.rawFinish,
+      providerState: stepSettlement?.providerState,
+      ...details
+    });
+  });
+  const failUnsettledTools = Effect.fn("SessionRunner.failUnsettledTools")((error, scope = "all") => failTools(error, scope));
+  const publish = Effect.fnUntraced(function* (event) {
+    switch (event.type) {
+      case "step-start":
+        yield* startAssistant();
+        return;
+      case "text-start":
+        outputStarted = true;
+        const startedTextOrdinal = yield* text.start(event.id, providerState(event.providerMetadata));
+        yield* bus.publish(SessionEvent2.Text.Started, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* startAssistant(),
+          ordinal: startedTextOrdinal
+        });
+        return;
+      case "text-delta":
+        yield* text.append(event.id, event.text, providerState(event.providerMetadata));
+        return;
+      case "text-end":
+        yield* text.end(event.id, providerState(event.providerMetadata), event.text);
+        return;
+      case "reasoning-start":
+        outputStarted = true;
+        const startedReasoningOrdinal = yield* reasoning.start(event.id, providerState(event.providerMetadata));
+        yield* bus.publish(SessionEvent2.Reasoning.Started, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* startAssistant(),
+          ordinal: startedReasoningOrdinal,
+          state: providerState(event.providerMetadata)
+        });
+        return;
+      case "reasoning-delta":
+        yield* reasoning.append(event.id, event.text, providerState(event.providerMetadata));
+        return;
+      case "reasoning-end":
+        yield* reasoning.end(event.id, providerState(event.providerMetadata), event.text);
+        return;
+      case "tool-input-start":
+        outputStarted = true;
+        yield* startToolInput(event);
+        return;
+      case "tool-input-delta": {
+        const tool = tools.get(event.id);
+        if (!tool)
+          return yield* Effect.die(new Error(`Tool input delta before start: ${event.id}`));
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (!toolInput.has(event.id))
+          return yield* Effect.die(new Error(`Tool input delta after end: ${event.id}`));
+        yield* toolInput.append(event.id, event.text);
+        return;
+      }
+      case "tool-input-end":
+        yield* endToolInput(event);
+        return;
+      case "tool-input-error":
+        outputStarted = true;
+        yield* failMalformedToolInput(event);
+        return;
+      case "tool-call": {
+        outputStarted = true;
+        const tool = tools.get(event.id) ?? (yield* startToolInput(event));
+        if (toolInput.has(event.id))
+          yield* endToolInput(event);
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool call name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (tool.called)
+          return yield* Effect.die(new Error(`Duplicate tool call: ${event.id}`));
+        tool.called = true;
+        tool.providerExecuted = event.providerExecuted === true;
+        yield* bus.publish(SessionEvent2.Tool.Called, {
+          sessionID: input.sessionID,
+          assistantMessageID,
+          id: event.id,
+          input: asRecord(event.input),
+          executed: tool.providerExecuted,
+          state: providerState(event.providerMetadata)
+        });
+        return;
+      }
+      case "tool-result": {
+        const tool = tools.get(event.id);
+        if (!tool?.called)
+          return yield* Effect.die(new Error(`Tool result before call: ${event.id}`));
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool result name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (tool.settled) {
+          if (event.result.type === "error")
+            return;
+          return yield* Effect.die(new Error(`Duplicate tool result: ${event.id}`));
+        }
+        tool.settled = true;
+        const executed = event.providerExecuted === true || tool.providerExecuted;
+        const resultState = providerState(event.providerMetadata);
+        if (event.result.type === "error") {
+          yield* bus.publish(SessionEvent2.Tool.Failed, {
+            sessionID: input.sessionID,
+            assistantMessageID,
+            id: event.id,
+            error: { type: "tool.execution", message: stringify(event.result.value) },
+            ...failureSnapshot(tool),
+            executed,
+            resultState
+          });
+          return;
+        }
+        yield* bus.publish(SessionEvent2.Tool.Success, {
+          sessionID: input.sessionID,
+          assistantMessageID,
+          id: event.id,
+          content: hostedContent(event.result),
+          executed,
+          resultState
+        });
+        return;
+      }
+      case "tool-error": {
+        const tool = tools.get(event.id);
+        if (!tool?.called)
+          return yield* Effect.die(new Error(`Tool error before call: ${event.id}`));
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool error name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (tool.settled)
+          return yield* Effect.die(new Error(`Duplicate tool error: ${event.id}`));
+        tool.settled = true;
+        yield* bus.publish(SessionEvent2.Tool.Failed, {
+          sessionID: input.sessionID,
+          assistantMessageID,
+          id: event.id,
+          error: event.message === `Unknown tool: ${event.name}` ? { type: "tool.unknown", message: event.message } : { type: "tool.execution", message: event.message },
+          ...failureSnapshot(tool),
+          executed: tool.providerExecuted,
+          resultState: providerState(event.providerMetadata)
+        });
+        return;
+      }
+      case "step-finish":
+        yield* flush();
+        if (stepSettlement)
+          return yield* Effect.die(new Error("Duplicate step finish"));
+        stepSettlement = {
+          finish: event.reason.normalized,
+          rawFinish: event.reason.raw,
+          providerState: providerState(event.providerMetadata),
+          tokens: tokens2(event.usage)
+        };
+        if (event.reason.normalized === "content-filter") {
+          providerFailed = true;
+          yield* failAssistant({ type: "provider.content-filter", message: "Provider blocked the response" });
+          return;
+        }
+        return;
+      case "finish":
+        return;
+      case "provider-error":
+        providerFailed = true;
+        yield* failAssistant({ type: "provider.unknown", message: event.message });
+        return;
+    }
+  }, Effect.uninterruptible);
+  const publishTraced = Effect.fn("SessionRunner.publishLLMEvent")(publish);
+  const progress = Effect.fnUntraced(function* (id, update) {
+    const tool = tools.get(id);
+    if (!tool?.called || tool.settled)
+      return yield* Effect.die(new Error(`Tool progress outside running call: ${id}`));
+    tool.progress = update;
+    yield* bus.publish(SessionEvent2.Tool.Progress, {
+      sessionID: input.sessionID,
+      assistantMessageID,
+      id,
+      metadata: update
+    });
+  });
+  const toolExecution = Effect.fnUntraced(function* (id, name, result) {
+    const tool = tools.get(id);
+    if (!tool?.called)
+      return yield* Effect.die(new Error(`Tool execution before call: ${id}`));
+    if (tool.name !== name)
+      return yield* Effect.die(new Error(`Tool execution name changed for ${id}: ${tool.name} -> ${name}`));
+    if (tool.settled)
+      return yield* Effect.die(new Error(`Duplicate tool execution: ${id}`));
+    tool.settled = true;
+    const content = result.content;
+    if (!isReadonlyArrayNonEmpty(content))
+      return yield* Effect.die(new Error(`Tool execution has no content: ${id}`));
+    yield* bus.publish(SessionEvent2.Tool.Success, {
+      sessionID: input.sessionID,
+      assistantMessageID,
+      id,
+      content,
+      ...result.metadata === undefined ? {} : { metadata: result.metadata },
+      executed: tool.providerExecuted
+    });
+  });
+  return {
+    publish: (event) => {
+      if (event.type === "text-delta" || event.type === "reasoning-delta" || event.type === "tool-input-delta")
+        return publish(event);
+      return publishTraced(event);
+    },
+    progress,
+    toolExecution,
+    flush,
+    failAssistant,
+    failTool,
+    publishStepFailure,
+    failUnsettledTools,
+    hasProviderError: () => providerFailed,
+    hasStarted: () => stepStarted,
+    record: () => ({
+      outputStarted,
+      providerFailed,
+      failure: stepFailure,
+      finish: stepSettlement,
+      needsContinuation: Iterable.some(tools.values(), (tool) => !tool.providerExecuted && (tool.called || tool.settled))
+    }),
+    startAssistant,
+    streamed
+  };
+};
+
+export { createLLMEventPublisher2 };