@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-xd8vz63e.js

@@ -0,0 +1,398 @@
+import {
+  exports_source
+} from "./permission-aftdh555.js";
+import {
+  exports_skill
+} from "./permission-zr271bqv.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/skill.ts
+var exports_skill2 = {};
+__export(exports_skill2, {
+  SkillPlugin: () => exports_skill2,
+  ReportContent: () => ReportContent,
+  Plugin: () => Plugin,
+  OpencodeDescription: () => OpencodeDescription,
+  OpencodeContent: () => OpencodeContent
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+import os from "os";
+
+// src/plugin/skill/opencode.md
+var opencode_default = `# OpenCode
+
+Use this guide as the starting point for work involving OpenCode itself. It
+covers the core concepts needed to configure and customize OpenCode, extend it
+with plugins, and build integrations with the OpenCode SDK, clients, and API.
+
+Full documentation is available at <https://opencode.ai/v2/docs/>. This overview is
+only an index of core concepts. Before answering a question about a topic below,
+fetch the URL named in that section and use the full page as the source of
+truth. Follow links from that page when the question needs more detail. Fetch
+<https://opencode.ai/v2/docs/> first when you need to discover the relevant
+documentation page.
+
+## Version policy
+
+Always answer for OpenCode V2 unless the user explicitly asks about V1,
+legacy OpenCode, or migrating from V1.
+
+Use only <https://opencode.ai/v2/docs/> documentation as the source of truth for V2.
+Do not use <https://opencode.ai/docs/>, which documents V1, and do not use
+general web search to resolve a V2 documentation question when the V2 docs or
+linked pages cover it. The schema served from
+<https://opencode.ai/config.json> may describe V1 even though V2 configuration
+files include that URL for editor integration. Never use it to infer V2 field
+names or shapes. If V2 documentation is missing or contradictory, state the
+uncertainty or ask for clarification instead of falling back to V1.
+
+V1 documentation and syntax may be consulted only when the user explicitly
+asks about V1 or when needed as migration input. Outputs and recommendations
+must still use V2 unless the user specifically requests a V1 result.
+
+## [Configuration](https://opencode.ai/v2/docs/config)
+
+OpenCode configuration uses JSON or JSONC. Include the published schema so the
+user's editor can validate fields and provide autocomplete:
+
+\`\`\`jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+}
+\`\`\`
+
+Global configuration lives at \`~/.config/opencode/opencode.json(c)\` and applies
+to every project for that user. Project configuration can live in any directory
+as \`opencode.json(c)\` or \`.opencode/opencode.json(c)\`, including nested packages
+in a monorepo.
+
+When OpenCode starts, it searches from the current directory up to the project
+root. It merges direct \`opencode.json(c)\` files from root to current directory,
+then does the same for \`.opencode/opencode.json(c)\` files. This means every
+\`.opencode\` config overrides every direct config. Global configuration has the
+lowest precedence.
+
+Common configuration fields include \`model\`, \`default_agent\`, \`permissions\`,
+\`agents\`, \`commands\`, \`plugins\`, \`providers\`, \`mcp\`, \`skills\`, \`instructions\`,
+\`references\`, \`formatter\`, and \`lsp\`.
+
+Do not guess field names or shapes. Fetch the V2 configuration guide and its
+linked topic guide as the source of truth, and preserve unrelated settings when
+editing an existing file. Keep the published \`$schema\` URL in configuration
+examples, but do not fetch it to determine the V2 configuration shape.
+
+See the [full configuration guide](https://opencode.ai/v2/docs/config) for
+every field, examples, config locations, and links to dedicated feature guides.
+
+## [V1 to V2 migration](https://opencode.ai/v2/docs/migrate-v1)
+
+For any request to migrate OpenCode configuration, agents, commands, skills,
+plugins, integrations, or other behavior from V1 to V2, read the full
+[migration guide](https://opencode.ai/v2/docs/migrate-v1) before acting. In
+the repository, its source is \`packages/www/content/docs/(Get started)/migrate-v1.mdx\`.
+
+V1 config files and \`.opencode/\` definitions are intended to remain compatible.
+The only intentional breaking changes are the server API and plugin API. Native
+V2 config uses more ergonomic shapes, but conversion is optional. When the user
+requests conversion, inspect the complete configuration, preserve behavior and
+unrelated settings, and apply only the relevant migrations from the guide. For
+plugin migrations, fetch and follow both the migration guide and the full
+[plugins guide](https://opencode.ai/v2/docs/build/plugins). If non-API V1
+functionality fails in V2, use the \`report\` skill to file it as a compatibility
+bug.
+
+## [Plugins](https://opencode.ai/v2/docs/build/plugins)
+
+For questions about creating, configuring, loading, publishing, or migrating
+plugins, fetch the full [plugins guide](https://opencode.ai/v2/docs/build/plugins)
+before answering. This includes questions about the Effect plugin API, hooks,
+transforms, tools, plugin context capabilities, and package entrypoints.
+
+## [Service](https://opencode.ai/v2/docs/troubleshooting#check-the-background-service)
+
+OpenCode uses a client-server architecture. Interfaces such as the TUI connect
+to a background OpenCode service, which owns sessions, configuration, plugins,
+permissions, and tool execution.
+
+OpenCode normally discovers or starts the shared background service
+automatically. If the service is stuck or unhealthy, restart it:
+
+\`\`\`sh
+opencode2 service restart
+\`\`\`
+
+Check its status after restarting:
+
+\`\`\`sh
+opencode2 service status
+\`\`\`
+
+## [API](https://opencode.ai/v2/docs/api)
+
+OpenCode exposes an HTTP API from its server. The API is described by an
+OpenAPI document available from the running server at \`/openapi.json\`.
+
+Use OpenCode's built-in \`api\` command for local requests. It uses the same
+discovery and authentication flow as the TUI and may start the background
+service when no compatible healthy service is available. It accepts either an
+HTTP method and path or an OpenAPI operation ID.
+
+Call an endpoint with an HTTP method and path:
+
+\`\`\`sh
+opencode2 api get /api/health
+\`\`\`
+
+Pass a request body with \`--data\` or \`-d\`, and additional headers with
+\`--header\` or \`-H\`:
+
+\`\`\`sh
+opencode2 api post /api/example --data '{"key":"value"}'
+opencode2 api get /api/example --header 'X-Example:value'
+\`\`\`
+
+Request bodies default to \`Content-Type: application/json\`. When OpenCode is
+connected to an explicit server instead of its managed background service, use
+the same configured server and authentication context rather than constructing
+an unauthenticated request separately.
+
+See the [full API reference](https://opencode.ai/v2/docs/api) for available
+endpoints, parameters, request bodies, and response schemas. The
+raw [OpenAPI specification](https://opencode.ai/v2/openapi.json) is also
+available for code generation and other tooling.
+
+## [Client](https://opencode.ai/v2/docs/build/client)
+
+For questions about connecting an application to OpenCode over the network,
+fetch the full [client guide](https://opencode.ai/v2/docs/build/client) before
+answering.
+
+\`@opencode-ai/client\` is the generated TypeScript client for the OpenCode HTTP
+API. Its methods and types come from the same contract as the API reference.
+The default entrypoint exposes Promise-based resource clients and async
+iterables for streaming endpoints. The \`@opencode-ai/client/effect\` entrypoint
+exposes typed Effects, Streams, and decoded OpenCode schema values. Its
+\`Service\` API can discover, start, stop, and authenticate with the local
+background service from a Node application.
+
+## [Troubleshooting](https://opencode.ai/v2/docs/troubleshooting)
+
+OpenCode runs a client and a background server. Start by determining whether a
+problem belongs to the client, the shared server, or one project.
+
+- Check the service with \`opencode2 service status\` and verify the API with
+  \`opencode2 api get /api/health\`.
+- Compare with \`opencode2 --standalone\`, which runs the TUI with a private
+  server, to isolate shared-service issues.
+- Inspect \`~/.local/share/opencode/log/opencode.log\`. Filter \`role=cli\` for
+  client startup and \`role=server\` for sessions, providers, plugins,
+  permissions, and tools.
+- Run one reproduction with \`OPENCODE_LOG_LEVEL=DEBUG\` when normal logs are not
+  sufficient.
+- Do not delete or edit the database, service registration, or service config
+  while diagnosing a problem. Back up persistent data before inspecting it
+  with external tools.
+- Redact API keys, authorization headers, prompts, file contents, and other
+  sensitive data before sharing diagnostics.
+
+See the [full troubleshooting guide](https://opencode.ai/v2/docs/troubleshooting)
+for service lifecycle commands, API inspection, log locations, explicit server
+connections, issue-reporting details, and local development paths.
+`;
+
+// src/plugin/skill/report.md
+var report_default = `<!--
+  Built-in skill. Name and description are registered in code at
+  packages/core/src/plugin/skill.ts. The body below becomes the skill's
+  content.
+-->
+
+# Report an opencode Issue
+
+Use this skill when the user wants to report an opencode issue or bug. Your job
+is to turn the user's problem into a useful GitHub issue with standard
+diagnostics plus the context needed to reproduce and resolve it.
+
+## Workflow
+
+1. Collect the standard diagnostics below.
+2. Ask only for missing details that are necessary to reproduce or understand
+   impact.
+3. Draft the issue in the standard format below.
+4. Publish it with GitHub CLI after the user confirms the title and body.
+
+Do not publish an issue without user confirmation. If GitHub CLI is not
+installed or not authenticated, explain the blocker and provide the exact issue
+title/body for the user.
+
+## Standard Diagnostics
+
+Collect these values when possible:
+
+- opencode version: run \`opencode --version\` or \`opencode2 --version\`,
+  depending on the executable in use.
+- Operating system: run \`uname -a\` on Unix-like systems, or \`ver\` on Windows.
+- Terminal: inspect \`$TERM\`, \`$TERM_PROGRAM\`, \`$COLORTERM\`, and any obvious
+  terminal app context the user provides.
+- Shell: inspect \`$SHELL\` on Unix-like systems, or \`%COMSPEC%\`/\`$ComSpec\` on
+  Windows when relevant.
+- Install/channel context: include whether this appears to be local, dev, beta,
+  or release if the version output or environment reveals it.
+- Active plugins: inspect opencode config for configured plugins when possible.
+  Check likely config locations such as \`opencode.json\`, \`opencode.jsonc\`,
+  \`.opencode/opencode.json\`, and \`~/.config/opencode/opencode.json\`. Record
+  configured plugin entries, local plugin files under \`.opencode/plugin/\` or
+  \`.opencode/plugins/\`, and note if plugin status could not be determined.
+
+If a diagnostic command fails, include \`Unavailable\` with the reason instead of
+guessing.
+
+## User-Specific Context
+
+Capture the details that make the issue actionable:
+
+- What the user was trying to do.
+- What happened.
+- What the user expected to happen.
+- Reproduction steps, ideally minimal and numbered.
+- Relevant logs, stack traces, screenshots, terminal output, or config snippets.
+- Whether the issue is reproducible consistently, intermittently, or only once.
+- Recent changes that may be related, such as updating opencode, changing
+  config, installing a plugin, changing terminal, or switching workspace.
+- Workarounds tried and whether they helped.
+
+Avoid pasting secrets. Redact tokens, API keys, private URLs, usernames, and
+project-specific confidential data unless the user explicitly says it is safe.
+
+## Issue Format
+
+Use this exact structure unless the repository issue template requires
+otherwise:
+
+\`\`\`markdown
+## Summary
+
+<!-- One or two sentences describing the bug and impact. -->
+
+## Environment
+
+- opencode version: <!-- value or Unavailable: reason -->
+- OS: <!-- value or Unavailable: reason -->
+- Terminal: <!-- value or Unavailable: reason -->
+- Shell: <!-- value or Unavailable: reason -->
+- Install/channel: <!-- value or Unavailable: reason -->
+- Active plugins: <!-- list, none found, or Unavailable: reason -->
+
+## Reproduction
+
+1. <!-- step -->
+2. <!-- step -->
+3. <!-- step -->
+
+## Expected Behavior
+
+<!-- What should have happened. -->
+
+## Actual Behavior
+
+<!-- What happened instead. Include exact errors when available. -->
+
+## Additional Context
+
+<!-- Logs, config snippets, screenshots, frequency, workarounds, related notes. -->
+\`\`\`
+
+Keep the title short and searchable. Prefer the form:
+
+\`\`\`text
+<area>: <specific failure or symptom>
+\`\`\`
+
+Examples: \`tui: skills dialog crashes outside location provider\`,
+\`cli: local service config writes release filename\`.
+
+## Publishing With GitHub CLI
+
+Use GitHub CLI from the repository checkout when available:
+
+\`\`\`sh
+gh issue create --title "<title>" --body-file <file>
+\`\`\`
+
+Write the body to a temporary markdown file first so quoting, newlines, logs,
+and code fences are preserved. If the issue belongs in a specific repository,
+use \`--repo owner/name\`. If labels are obvious and the repo accepts them, add
+\`--label bug\`; otherwise omit labels rather than guessing.
+
+After publishing, report the created issue URL to the user and mention any
+diagnostics that were unavailable.
+`;
+
+// src/plugin/skill.ts
+var OpencodeContent = opencode_default;
+var ReportContent = report_default;
+var OpencodeDescription = "Use this skill for any question about OpenCode itself, including how OpenCode works, using or configuring it, migrating from V1 to V2, troubleshooting it, developing plugins or integrations, using the OpenCode SDK, clients, server, or API, and contributing to the OpenCode codebase. Also use it for OpenCode agents, commands, skills, tools, permissions, MCP servers, providers, models, themes, keybinds, formatters, the CLI, TUI, desktop app, and web app.";
+var REPORT_DESCRIPTION = "Use when the user wants to report an opencode issue or bug. Collect standard diagnostics, add user-specific reproduction context, and publish the issue with GitHub CLI.";
+var Plugin = define({
+  id: "opencode.skill",
+  effect: Effect.fn(function* (ctx) {
+    const reportContent = yield* reportContentWithDiagnostics(ctx.app);
+    yield* ctx.skill.transform((draft) => {
+      draft.add(exports_skill.Info.make({
+        id: exports_skill.ID.make("opencode"),
+        name: exports_skill.Name.make("OpenCode"),
+        description: OpencodeDescription,
+        location: AbsolutePath.make("/builtin/opencode.md"),
+        content: OpencodeContent
+      }));
+      draft.add(exports_skill.Info.make({
+        id: exports_skill.ID.make("report"),
+        name: exports_skill.Name.make("Report"),
+        description: REPORT_DESCRIPTION,
+        slash: true,
+        location: AbsolutePath.make("/builtin/report.md"),
+        content: reportContent
+      }));
+    });
+  })
+});
+var reportContentWithDiagnostics = Effect.fn("SkillPlugin.reportContentWithDiagnostics")(function* (app) {
+  const plugins = yield* configuredPlugins().pipe(Effect.orElseSucceed(() => ["Unavailable: failed to inspect config"]));
+  return [
+    ReportContent,
+    "",
+    "## Runtime Diagnostics Snapshot",
+    "",
+    "These values were captured when the built-in report skill was registered. Verify them before publishing.",
+    "",
+    `- opencode version: ${app.version}`,
+    `- install/channel: ${app.channel}`,
+    `- OS: ${os.type()} ${os.release()} (${os.platform()} ${os.arch()})`,
+    `- Terminal: ${terminal()}`,
+    `- Shell: ${shell()}`,
+    `- Active plugins: ${plugins.length === 0 ? "None found in config" : plugins.join(", ")}`
+  ].join(`
+`);
+});
+var configuredPlugins = Effect.fn("SkillPlugin.configuredPlugins")(function* () {
+  const sources = yield* exports_source.Service;
+  return (yield* sources.operations()).map((operation) => operation.type === "remove" ? `-${operation.target}` : operation.target).toSorted();
+});
+function terminal() {
+  return [
+    process.env.TERM_PROGRAM ? `TERM_PROGRAM=${process.env.TERM_PROGRAM}` : undefined,
+    process.env.TERM ? `TERM=${process.env.TERM}` : undefined,
+    process.env.COLORTERM ? `COLORTERM=${process.env.COLORTERM}` : undefined
+  ].filter((item) => item !== undefined).join(", ") || "Unavailable: terminal environment variables are not set";
+}
+function shell() {
+  return process.env.SHELL ?? process.env.ComSpec ?? process.env.COMSPEC ?? "Unavailable: shell environment variable is not set";
+}
+
+export { OpencodeContent, ReportContent, OpencodeDescription, Plugin, exports_skill2 as exports_skill };

package/dist/chunks/permission-xfd1xnk3.js

@@ -0,0 +1,49 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/model.ts
+var exports_model = {};
+__export(exports_model, {
+  parse: () => parse,
+  compatibility: () => compatibility,
+  VariantID: () => VariantID,
+  Ref: () => Ref,
+  ReasoningField: () => ReasoningField,
+  Model: () => exports_model,
+  Info: () => Info,
+  ID: () => ID,
+  Family: () => Family,
+  Cost: () => Cost,
+  Compatibility: () => Compatibility,
+  Capabilities: () => Capabilities
+});
+import { Model } from "@opencode-ai/schema/model";
+var ID = Model.ID;
+var VariantID = Model.VariantID;
+var Family = Model.Family;
+var ReasoningField = Model.ReasoningField;
+var Compatibility = Model.Compatibility;
+var Capabilities = Model.Capabilities;
+var Cost = Model.Cost;
+var Ref = Model.Ref;
+var Info = Model.Info;
+function compatibility(input) {
+  if (typeof input === "string")
+    return { reasoningField: input };
+  if (typeof input !== "object" || input === null || Array.isArray(input) || !("field" in input))
+    return;
+  return typeof input.field === "string" ? { reasoningField: input.field } : undefined;
+}
+function parse(input) {
+  const [providerID, ...modelID] = input.split("/");
+  return {
+    providerID: exports_provider.ID.make(providerID),
+    modelID: ID.make(modelID.join("/"))
+  };
+}
+
+export { ID, VariantID, Family, ReasoningField, Compatibility, Capabilities, Cost, Ref, Info, compatibility, parse, exports_model };

package/dist/chunks/permission-xfrawapx.js

@@ -0,0 +1,75 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/run-coordinator.ts
+var exports_run_coordinator = {};
+__export(exports_run_coordinator, {
+  make: () => make,
+  SessionRunCoordinator: () => exports_run_coordinator
+});
+import { Deferred, Effect, Fiber, FiberSet } from "effect";
+var make = (options) => Effect.gen(function* () {
+  const executions = new Map;
+  const fork = yield* FiberSet.makeRuntime();
+  const loop = (key, execution, force) => Effect.suspend(() => options.drain(key, force)).pipe(Effect.flatMap(() => Effect.suspend(() => {
+    if (execution.stopping || !execution.pendingWake)
+      return Effect.void;
+    execution.pendingWake = false;
+    return Effect.yieldNow.pipe(Effect.andThen(loop(key, execution, false)));
+  })));
+  const start = (key, force) => {
+    const execution = {
+      done: Deferred.makeUnsafe(),
+      pendingWake: false,
+      stopping: false
+    };
+    executions.set(key, execution);
+    execution.owner = fork(Effect.yieldNow.pipe(Effect.andThen(Effect.uninterruptible(options.started?.(key) ?? Effect.void)), Effect.andThen(loop(key, execution, force)), Effect.onExit((exit) => Effect.sync(() => {
+      execution.owner = undefined;
+    }).pipe(Effect.andThen(options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void))), Effect.onExit((exit) => Effect.sync(() => settle(key, execution, exit))), Effect.exit, Effect.asVoid));
+    return execution;
+  };
+  const settle = (key, execution, exit) => {
+    if (execution.pendingWake)
+      start(key, false);
+    else
+      executions.delete(key);
+    Deferred.doneUnsafe(execution.done, exit);
+  };
+  const run = (key) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution !== undefined) {
+      if (execution.stopping)
+        return Deferred.await(execution.done).pipe(Effect.andThen(run(key)));
+      return Deferred.await(execution.done);
+    }
+    return Deferred.await(start(key, true).done);
+  });
+  const wake = (key) => Effect.sync(() => {
+    const execution = executions.get(key);
+    if (execution !== undefined) {
+      execution.pendingWake = true;
+      return;
+    }
+    start(key, false);
+  });
+  const interrupt = (key, reason) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution?.owner === undefined || execution.stopping)
+      return Effect.void;
+    execution.stopping = true;
+    execution.pendingWake = false;
+    execution.interruptionReason = reason;
+    return Fiber.interrupt(execution.owner);
+  });
+  const awaitIdle = (key) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution === undefined)
+      return Effect.void;
+    return Deferred.await(execution.done).pipe(Effect.exit, Effect.andThen(awaitIdle(key)));
+  });
+  return { active: Effect.sync(() => new Set(executions.keys())), run, wake, interrupt, awaitIdle };
+});
+
+export { make, exports_run_coordinator };

package/dist/chunks/permission-xgv25zxy.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/generate.ts
+var exports_generate = {};
+__export(exports_generate, {
+  SessionGenerate: () => exports_generate,
+  Service: () => Service
+});
+import { Context } from "effect";
+
+class Service extends Context.Service()("@opencode/SessionGenerate") {
+}
+
+export { Service, exports_generate };

package/dist/chunks/permission-xwftk1fd.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./permission-0zz82cjq.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/venice.ts
+var VenicePlugin = createProviderPlugin({
+  id: "opencode.provider.venice",
+  package: "venice-ai-sdk-provider",
+  load: async (options) => {
+    const { createVenice } = await import("venice-ai-sdk-provider");
+    return createVenice(options);
+  }
+});
+
+export { VenicePlugin };

package/dist/chunks/permission-y0x38cee.js

@@ -0,0 +1,28 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/provider-options.ts
+var exports_provider_options = {};
+__export(exports_provider_options, {
+  provider: () => provider,
+  model: () => model,
+  ConfigProviderOptionsV1: () => exports_provider_options
+});
+function provider(options) {
+  const headers = options.headers;
+  const body = options.body;
+  const settings = Object.fromEntries(Object.entries(options).filter(([key]) => key !== "headers" && key !== "body"));
+  const headerOverlay = typeof headers === "object" && headers !== null && !Array.isArray(headers) ? Object.fromEntries(Object.entries(headers).filter((entry) => typeof entry[1] === "string")) : undefined;
+  const bodyOverlay = typeof body === "object" && body !== null && !Array.isArray(body) ? { ...body } : undefined;
+  return {
+    settings,
+    headers: headerOverlay,
+    body: bodyOverlay
+  };
+}
+function model(options) {
+  return { ...options };
+}
+
+export { provider, model, exports_provider_options };