@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-rmgfhn2t.js

@@ -0,0 +1,380 @@
+import {
+  exports_message
+} from "./permission-25pxtba7.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/message-updater.ts
+var exports_message_updater = {};
+__export(exports_message_updater, {
+  update: () => update,
+  SessionMessageUpdater: () => exports_message_updater
+});
+import { castDraft, produce } from "immer";
+import { DateTime, Effect, Match, pipe } from "effect";
+function update(adapter, event) {
+  const latestTool = (assistant, id) => assistant?.content.findLast((item) => item.type === "tool" && (id === undefined || item.id === id));
+  const latestText = (assistant) => assistant?.content.findLast((item) => item.type === "text");
+  const latestReasoning = (assistant) => assistant?.content.findLast((item) => item.type === "reasoning" && !item.time?.completed);
+  const updateOwnedAssistant = (messageID, recipe) => Effect.gen(function* () {
+    const assistant = yield* adapter.getAssistant(messageID);
+    if (assistant)
+      yield* adapter.updateAssistant(produce(assistant, recipe));
+  });
+  const clearCurrentRetry = Effect.gen(function* () {
+    const assistant = yield* adapter.getCurrentAssistant();
+    if (assistant?.retry) {
+      yield* adapter.updateAssistant(produce(assistant, (draft) => {
+        draft.retry = undefined;
+      }));
+    }
+  });
+  const project = pipe(Match.type(), Match.discriminatorsExhaustive("type")({
+    "session.created": () => Effect.void,
+    "session.usage.recorded": () => Effect.void,
+    "session.agent.selected": (event2) => {
+      return Effect.gen(function* () {
+        const previous = event2.data.previous ?? (yield* adapter.getAgent());
+        yield* adapter.appendMessage(exports_message.AgentSelected.make({
+          id: exports_message.ID.fromEvent(event2.id),
+          type: "agent-switched",
+          metadata: event2.metadata,
+          agent: event2.data.agent,
+          previous,
+          time: { created: event2.created }
+        }));
+      });
+    },
+    "session.model.selected": (event2) => {
+      return Effect.gen(function* () {
+        const previous = event2.data.previous ?? (yield* adapter.getModel());
+        yield* adapter.appendMessage(exports_message.ModelSelected.make({
+          id: exports_message.ID.fromEvent(event2.id),
+          type: "model-switched",
+          metadata: event2.metadata,
+          model: event2.data.model,
+          previous,
+          time: { created: event2.created }
+        }));
+      });
+    },
+    "session.moved": (event2) => {
+      return Effect.gen(function* () {
+        yield* adapter.appendMessage(exports_message.LocationSwitched.make({
+          id: exports_message.ID.fromEvent(event2.id),
+          type: "location-switched",
+          metadata: event2.metadata,
+          location: event2.data.location,
+          projectID: event2.data.projectID,
+          subpath: event2.data.subpath,
+          previous: yield* adapter.getLocation(),
+          time: { created: event2.created }
+        }));
+      });
+    },
+    "session.renamed": () => Effect.void,
+    "session.deleted": () => Effect.void,
+    "session.forked": () => Effect.void,
+    "session.input.promoted": () => Effect.void,
+    "session.input.admitted": () => Effect.void,
+    "session.input.cancelled": () => Effect.void,
+    "session.input.steered": () => Effect.void,
+    "session.input.queued": () => Effect.void,
+    "session.execution.started": () => Effect.void,
+    "session.execution.succeeded": () => clearCurrentRetry,
+    "session.execution.failed": () => clearCurrentRetry,
+    "session.execution.interrupted": () => clearCurrentRetry,
+    "session.instructions.updated": (event2) => {
+      if (event2.data.text === undefined)
+        return Effect.void;
+      return adapter.appendMessage(exports_message.System.make({
+        id: exports_message.ID.fromEvent(event2.id),
+        type: "system",
+        text: event2.data.text,
+        description: `Instructions updated: ${Object.keys(event2.data.delta).join(", ")}`,
+        metadata: event2.metadata,
+        time: { created: event2.created }
+      }));
+    },
+    "session.synthetic": (event2) => {
+      return adapter.appendMessage(exports_message.Synthetic.make({
+        text: event2.data.text,
+        description: event2.data.description,
+        metadata: event2.data.metadata,
+        id: exports_message.ID.fromEvent(event2.id),
+        type: "synthetic",
+        time: { created: event2.created }
+      }));
+    },
+    "session.skill.activated": (event2) => {
+      return adapter.appendMessage(exports_message.Skill.make({
+        id: exports_message.ID.fromEvent(event2.id),
+        type: "skill",
+        skill: event2.data.id,
+        name: event2.data.name,
+        text: event2.data.text,
+        metadata: event2.metadata,
+        time: { created: event2.created }
+      }));
+    },
+    "session.shell.started": (event2) => {
+      return adapter.appendMessage(exports_message.Shell.make({
+        id: exports_message.ID.fromEvent(event2.id),
+        type: "shell",
+        metadata: event2.metadata,
+        shellID: event2.data.shell.id,
+        command: event2.data.shell.command,
+        status: event2.data.shell.status,
+        time: { created: event2.created }
+      }));
+    },
+    "session.shell.ended": (event2) => {
+      return Effect.gen(function* () {
+        const currentShell = yield* adapter.getShell(event2.data.shell.id);
+        if (currentShell) {
+          yield* adapter.updateShell(produce(currentShell, (draft) => {
+            draft.status = event2.data.shell.status;
+            draft.exit = event2.data.shell.exit;
+            draft.output = event2.data.output;
+            draft.time.completed = event2.created;
+          }));
+        }
+      });
+    },
+    "session.step.started": (event2) => {
+      return Effect.gen(function* () {
+        const existing = yield* adapter.getAssistant(event2.data.assistantMessageID);
+        if (existing) {
+          yield* adapter.updateAssistant(produce(existing, (draft) => {
+            draft.agent = event2.data.agent;
+            draft.model = castDraft(event2.data.model);
+            draft.retry = undefined;
+            draft.error = undefined;
+            draft.finish = undefined;
+            draft.time.completed = undefined;
+            if (event2.data.snapshot)
+              draft.snapshot = { ...draft.snapshot, start: event2.data.snapshot };
+          }));
+          return;
+        }
+        const currentAssistant = yield* adapter.getCurrentAssistant();
+        if (currentAssistant) {
+          yield* adapter.updateAssistant(produce(currentAssistant, (draft) => {
+            draft.retry = undefined;
+            draft.time.completed = event2.created;
+          }));
+        }
+        yield* adapter.appendMessage(exports_message.Assistant.make({
+          id: event2.data.assistantMessageID,
+          type: "assistant",
+          agent: event2.data.agent,
+          model: event2.data.model,
+          metadata: event2.metadata,
+          time: { created: event2.created },
+          content: [],
+          snapshot: event2.data.snapshot ? { start: event2.data.snapshot } : undefined
+        }));
+      });
+    },
+    "session.step.ended": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        draft.time.completed = event2.created;
+        draft.finish = event2.data.finish;
+        draft.cost = event2.data.cost;
+        draft.tokens = event2.data.tokens;
+        if (event2.data.snapshot || event2.data.files)
+          draft.snapshot = {
+            ...draft.snapshot,
+            end: event2.data.snapshot,
+            files: event2.data.files ? Array.from(event2.data.files) : undefined
+          };
+      });
+    },
+    "session.step.failed": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        draft.time.completed = event2.created;
+        draft.finish = "error";
+        draft.error = castDraft(event2.data.error);
+        draft.retry = undefined;
+        if (event2.data.cost !== undefined && event2.data.tokens !== undefined) {
+          draft.cost = event2.data.cost;
+          draft.tokens = castDraft(event2.data.tokens);
+        }
+        if (event2.data.snapshot || event2.data.files)
+          draft.snapshot = {
+            ...draft.snapshot,
+            end: event2.data.snapshot,
+            files: event2.data.files ? Array.from(event2.data.files) : undefined
+          };
+      });
+    },
+    "session.text.started": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(exports_message.AssistantText.make({ type: "text", text: "" })));
+      });
+    },
+    "session.text.ended": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        const match = latestText(draft);
+        if (match) {
+          match.text = event2.data.text;
+          match.state = castDraft(event2.data.state);
+        }
+      });
+    },
+    "session.tool.input.started": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(exports_message.AssistantTool.make({
+          type: "tool",
+          id: event2.data.id,
+          name: event2.data.name,
+          time: { created: event2.created },
+          state: exports_message.ToolStateStreaming.make({ status: "streaming", input: "" })
+        })));
+      });
+    },
+    "session.tool.input.ended": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event2.data.id);
+        if (match && match.state.status === "streaming")
+          match.state.input = event2.data.text;
+      });
+    },
+    "session.tool.called": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event2.data.id);
+        if (match) {
+          match.executed = event2.data.executed;
+          match.providerState = event2.data.state;
+          match.time.ran = event2.created;
+          match.state = castDraft(exports_message.ToolStateRunning.make({
+            status: "running",
+            input: event2.data.input,
+            metadata: {}
+          }));
+        }
+      });
+    },
+    "session.tool.success": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event2.data.id);
+        if (match && match.state.status === "running") {
+          match.executed = event2.data.executed || match.executed === true;
+          match.providerResultState = event2.data.resultState;
+          match.time.completed = event2.created;
+          match.state = castDraft(exports_message.ToolStateCompleted.make({
+            status: "completed",
+            input: match.state.input,
+            content: event2.data.content,
+            ...event2.data.metadata === undefined ? {} : { metadata: event2.data.metadata }
+          }));
+        }
+      });
+    },
+    "session.tool.failed": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event2.data.id);
+        if (match && (match.state.status === "streaming" || match.state.status === "running")) {
+          match.executed = event2.data.executed || match.executed === true;
+          match.providerResultState = event2.data.resultState;
+          match.time.completed = event2.created;
+          match.state = castDraft(exports_message.ToolStateError.make({
+            status: "error",
+            error: event2.data.error,
+            input: typeof match.state.input === "string" ? {} : match.state.input,
+            ...event2.data.content === undefined ? {} : { content: event2.data.content },
+            ...event2.data.metadata === undefined ? {} : { metadata: event2.data.metadata }
+          }));
+        }
+      });
+    },
+    "session.reasoning.started": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(exports_message.AssistantReasoning.make({
+          type: "reasoning",
+          text: "",
+          state: event2.data.state,
+          time: { created: event2.created }
+        })));
+      });
+    },
+    "session.reasoning.ended": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        const match = latestReasoning(draft);
+        if (match) {
+          match.text = event2.data.text;
+          match.time = { created: match.time?.created ?? event2.created, completed: event2.created };
+          if (event2.data.state !== undefined)
+            match.state = event2.data.state;
+        }
+      });
+    },
+    "session.retry.scheduled": (event2) => {
+      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
+        draft.retry = {
+          attempt: event2.data.attempt,
+          at: DateTime.makeUnsafe(event2.data.at),
+          error: castDraft(event2.data.error)
+        };
+      });
+    },
+    "session.compaction.admitted": () => Effect.void,
+    "session.compaction.started": (event2) => adapter.appendMessage(exports_message.CompactionRunning.make({
+      id: event2.data.inputID ?? exports_message.ID.fromEvent(event2.id),
+      type: "compaction",
+      status: "running",
+      metadata: event2.metadata,
+      reason: event2.data.reason,
+      summary: "",
+      recent: event2.data.recent ?? "",
+      time: { created: event2.created }
+    })),
+    "session.compaction.ended": (event2) => {
+      return Effect.gen(function* () {
+        const current = yield* adapter.getCompaction();
+        if (current?.status === "running") {
+          yield* adapter.updateCompaction({
+            ...current,
+            status: "completed",
+            reason: event2.data.reason,
+            summary: event2.data.text,
+            recent: event2.data.recent
+          });
+          return;
+        }
+        yield* adapter.appendMessage(exports_message.Compaction.make({
+          id: exports_message.ID.fromEvent(event2.id),
+          type: "compaction",
+          status: "completed",
+          metadata: event2.metadata,
+          reason: event2.data.reason,
+          summary: event2.data.text,
+          recent: event2.data.recent,
+          time: { created: event2.created }
+        }));
+      });
+    },
+    "session.compaction.failed": (event2) => Effect.gen(function* () {
+      const current = yield* adapter.getCompaction();
+      const failed = exports_message.CompactionFailed.make({
+        id: current?.id ?? event2.data.inputID ?? exports_message.ID.fromEvent(event2.id),
+        type: "compaction",
+        status: "failed",
+        metadata: current?.metadata ?? event2.metadata,
+        reason: event2.data.reason,
+        error: event2.data.error,
+        time: current?.time ?? { created: event2.created }
+      });
+      if (current?.status === "running")
+        return yield* adapter.updateCompaction(failed);
+      yield* adapter.appendMessage(failed);
+    }),
+    "session.revert.staged": () => Effect.void,
+    "session.revert.cleared": () => Effect.void,
+    "session.revert.committed": () => Effect.void
+  }));
+  return project(event);
+}
+
+export { update, exports_message_updater };

package/dist/chunks/permission-rnfxxvxb.js

@@ -0,0 +1,120 @@
+import {
+  exports_question
+} from "./permission-csanxt95.js";
+import {
+  exports_form
+} from "./permission-y1tgg8ry.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/plugin/question.ts
+var exports_question2 = {};
+__export(exports_question2, {
+  toModelOutput: () => toModelOutput,
+  name: () => name,
+  description: () => description,
+  QuestionTool: () => exports_question2,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input,
+  CancelledError: () => CancelledError
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+var name = "question";
+var description = `Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- A "Type your own answer" option is added automatically; don't include a separate option for free form answers
+- Set \`multiple: true\` to allow selecting more than one option
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`;
+var Input = Schema.Struct({
+  questions: Schema.Array(exports_question.Prompt).check(Schema.isNonEmpty()).annotate({ description: "Questions to ask" })
+});
+var Output = Schema.Struct({
+  answers: Schema.Array(exports_question.Answer)
+});
+
+class CancelledError extends Schema.TaggedErrorClass()("QuestionTool.CancelledError", {}) {
+  get message() {
+    return "The user dismissed this question";
+  }
+}
+var toModelOutput = (questions, answers) => {
+  const formatted = questions.map((question, index) => `"${question.question}"="${answers[index]?.length ? answers[index].join(", ") : "Unanswered"}"`).join(", ");
+  return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`;
+};
+var Plugin = {
+  id: "opencode.tool.question",
+  effect: Effect.fn("QuestionTool.Plugin")(function* (ctx) {
+    const forms = yield* exports_form.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => permission.assert({
+        action: "question",
+        resources: ["*"],
+        sessionID: context.sessionID,
+        agent: context.agent,
+        source: { type: "tool", messageID: context.messageID, id: context.id }
+      }).pipe(Effect.mapError((error) => new ToolFailure({ message: "Permission denied: question", error })), Effect.andThen(forms.ask({
+        sessionID: context.sessionID,
+        title: "Questions",
+        metadata: {
+          kind: "question",
+          tool: { messageID: context.messageID, id: context.id }
+        },
+        fields: [
+          toField(input.questions[0], 0),
+          ...input.questions.slice(1).map((question, index) => toField(question, index + 1))
+        ]
+      }).pipe(Effect.orDie)), Effect.flatMap((state) => {
+        if (state.status === "cancelled")
+          return Effect.die(new CancelledError);
+        const output = {
+          answers: input.questions.map((_, index) => {
+            const value = state.answer[`q${index}`];
+            if (value === undefined)
+              return [];
+            if (typeof value === "object")
+              return Array.from(value);
+            return [String(value)];
+          })
+        };
+        return Effect.succeed({
+          output,
+          content: toModelOutput(input.questions, output.answers),
+          metadata: { answers: output.answers }
+        });
+      }))
+    })).pipe(Effect.orDie);
+  })
+};
+function toField(question, index) {
+  return {
+    key: `q${index}`,
+    title: question.header,
+    description: question.question,
+    type: question.multiple === true ? "multiselect" : "string",
+    options: question.options.map((option) => ({
+      value: option.label,
+      label: option.label,
+      description: option.description
+    })),
+    custom: true
+  };
+}
+
+export { name, description, Input, Output, CancelledError, toModelOutput, Plugin, exports_question2 as exports_question };

package/dist/chunks/permission-rqswsgbs.js

@@ -0,0 +1,105 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/amazon-bedrock.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+function resolveModelID(modelID, region) {
+  const crossRegionPrefixes = ["global.", "us.", "eu.", "jp.", "apac.", "au."];
+  if (crossRegionPrefixes.some((prefix2) => modelID.startsWith(prefix2)))
+    return modelID;
+  const resolvedRegion = region ?? "us-east-1";
+  const regionPrefix = resolvedRegion.split("-")[0];
+  if (regionPrefix === "us") {
+    const requiresPrefix = ["nova-micro", "nova-lite", "nova-pro", "nova-premier", "nova-2", "claude", "deepseek"].some((item) => modelID.includes(item));
+    if (requiresPrefix && !resolvedRegion.startsWith("us-gov"))
+      return `${regionPrefix}.${modelID}`;
+    return modelID;
+  }
+  if (regionPrefix === "eu") {
+    const regionRequiresPrefix = [
+      "eu-west-1",
+      "eu-west-2",
+      "eu-west-3",
+      "eu-north-1",
+      "eu-central-1",
+      "eu-south-1",
+      "eu-south-2"
+    ].some((item) => resolvedRegion.includes(item));
+    const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "llama3", "pixtral"].some((item) => modelID.includes(item));
+    return regionRequiresPrefix && modelRequiresPrefix ? `${regionPrefix}.${modelID}` : modelID;
+  }
+  if (regionPrefix !== "ap")
+    return modelID;
+  const australia = ["ap-southeast-2", "ap-southeast-4"].includes(resolvedRegion);
+  if (australia && ["anthropic.claude-sonnet-4-5", "anthropic.claude-haiku"].some((item) => modelID.includes(item))) {
+    return `au.${modelID}`;
+  }
+  const prefix = resolvedRegion === "ap-northeast-1" ? "jp" : "apac";
+  return ["claude", "nova-lite", "nova-micro", "nova-pro"].some((item) => modelID.includes(item)) ? `${prefix}.${modelID}` : modelID;
+}
+function selectMantleModel(sdk, modelID) {
+  if (modelID === "openai.gpt-oss-safeguard-20b" || modelID === "openai.gpt-oss-safeguard-120b")
+    return sdk.chat(modelID);
+  return sdk.responses(modelID);
+}
+var AmazonBedrockPlugin = define({
+  id: "opencode.provider.amazon-bedrock",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/amazon-bedrock")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          if (typeof provider.settings?.endpoint !== "string")
+            return;
+          provider.settings.baseURL = provider.settings.endpoint;
+          delete provider.settings.endpoint;
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (!["@ai-sdk/amazon-bedrock", "@ai-sdk/amazon-bedrock/mantle"].includes(evt.package))
+        return;
+      const options = { ...evt.options };
+      const profile = typeof options.profile === "string" ? options.profile : process.env.AWS_PROFILE;
+      const region = typeof options.region === "string" ? options.region : process.env.AWS_REGION ?? "us-east-1";
+      const bearerToken = process.env.AWS_BEARER_TOKEN_BEDROCK ?? (typeof options.bearerToken === "string" ? options.bearerToken : undefined);
+      if (bearerToken && !process.env.AWS_BEARER_TOKEN_BEDROCK)
+        process.env.AWS_BEARER_TOKEN_BEDROCK = bearerToken;
+      const containerCreds = Boolean(process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI || process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI);
+      options.region = region;
+      if (typeof options.endpoint === "string")
+        options.baseURL = options.endpoint;
+      if (!bearerToken && options.credentialProvider === undefined) {
+        const { fromNodeProviderChain } = yield* Effect.promise(() => import("@aws-sdk/credential-providers"));
+        options.credentialProvider = fromNodeProviderChain(profile ? { profile } : {});
+      }
+      if (evt.package === "@ai-sdk/amazon-bedrock/mantle") {
+        const mod2 = yield* Effect.promise(() => import("@ai-sdk/amazon-bedrock/mantle"));
+        evt.sdk = mod2.createBedrockMantle(options);
+        return;
+      }
+      const mod = yield* Effect.promise(() => import("@ai-sdk/amazon-bedrock"));
+      evt.sdk = mod.createAmazonBedrock(options);
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== exports_provider.ID.amazonBedrock)
+        return;
+      if (exports_provider.isAISDK(evt.model.package) && exports_provider.packageName(evt.model.package) === "@ai-sdk/amazon-bedrock/mantle") {
+        evt.language = selectMantleModel(evt.sdk, evt.model.modelID ?? evt.model.id);
+        return;
+      }
+      const region = typeof evt.options.region === "string" ? evt.options.region : process.env.AWS_REGION;
+      evt.language = evt.sdk.languageModel(resolveModelID(evt.model.modelID ?? evt.model.id, region));
+    }));
+  })
+});
+
+export { AmazonBedrockPlugin };