@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-9q1hedyj.js

@@ -0,0 +1,468 @@
+import {
+  exports_usage
+} from "./permission-8ywqk2j9.js";
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+
+// src/session/runner/publish-llm-event.ts
+import { Effect } from "effect";
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : { value };
+var nonEmpty = (content) => content.length > 0 ? content : undefined;
+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") {
+    const content = nonEmpty(result.value);
+    if (content !== undefined)
+      return content;
+  }
+  return [{ type: "text", text: stringify(result.value) }];
+};
+var createLLMEventPublisher = (bus, input) => {
+  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 stepFailed = 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(SessionEvent.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 providerState = (metadata) => metadata?.[input.providerMetadataKey];
+  const fragments = (name, ended, 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: [], state });
+      return Effect.succeed(ordinal);
+    });
+    const append = (id, value, state) => Effect.suspend(() => {
+      const current = chunks.get(id);
+      if (!current)
+        return Effect.die(new Error(`${name} delta before start: ${id}`));
+      current.values.push(value);
+      if (state !== undefined)
+        current.state = { ...current.state, ...state };
+      return Effect.succeed(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}`));
+      yield* ended(id, value ?? current.values.join(""), current.ordinal, state === undefined ? current.state : { ...current.state, ...state });
+      chunks.delete(id);
+    });
+    const flush2 = Effect.fnUntraced(function* () {
+      for (const id of chunks.keys())
+        yield* end(id);
+    });
+    return { start, append, end, flush: flush2, has: (id) => chunks.has(id) };
+  };
+  const text = fragments("text", (_textID, value, ordinal, state) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Text.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      text: value,
+      state
+    });
+  }), true);
+  const reasoning = fragments("reasoning", (_reasoningID, value, ordinal, state) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Reasoning.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      text: value,
+      state
+    });
+  }), 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(SessionEvent.Tool.Input.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.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}`));
+    const assistantMessageID2 = yield* startAssistant();
+    tools.set(event.id, {
+      assistantMessageID: assistantMessageID2,
+      name: event.name,
+      called: false,
+      settled: false,
+      providerExecuted: event.providerExecuted === true
+    });
+    yield* toolInput.start(event.id);
+    yield* bus.publish(SessionEvent.Tool.Input.Started, {
+      sessionID: input.sessionID,
+      assistantMessageID: assistantMessageID2,
+      id: event.id,
+      name: event.name
+    });
+  });
+  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) {
+    if (!tools.has(event.id))
+      yield* startToolInput(event);
+    const tool = tools.get(event.id);
+    if (!tool || 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(SessionEvent.Tool.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.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")(function* () {
+    yield* 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(SessionEvent.Tool.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      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 (stepFailed || stepFailure === undefined)
+      return;
+    const assistantMessageID2 = yield* startAssistant();
+    stepFailed = true;
+    yield* bus.publish(SessionEvent.Step.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID: assistantMessageID2,
+      error: stepFailure,
+      ...details
+    });
+  });
+  const failUnsettledTools = Effect.fn("SessionRunner.failUnsettledTools")(function* (error, scope = "all") {
+    return yield* failTools(error, scope);
+  });
+  const assistantMessageIDForTool = (id) => {
+    const tool = tools.get(id);
+    return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(new Error(`Unknown tool call: ${id}`));
+  };
+  const publish = Effect.fn("SessionRunner.publishLLMEvent")(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(SessionEvent.Text.Started, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* startAssistant(),
+          ordinal: startedTextOrdinal
+        });
+        return;
+      case "text-delta":
+        const deltaTextOrdinal = yield* text.append(event.id, event.text, providerState(event.providerMetadata));
+        yield* bus.publish(SessionEvent.Text.Delta, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* currentAssistantMessageID(),
+          ordinal: deltaTextOrdinal,
+          delta: event.text
+        });
+        return;
+      case "text-end":
+        yield* text.end(event.id, providerState(event.providerMetadata));
+        return;
+      case "reasoning-start":
+        outputStarted = true;
+        const startedReasoningOrdinal = yield* reasoning.start(event.id, providerState(event.providerMetadata));
+        yield* bus.publish(SessionEvent.Reasoning.Started, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* startAssistant(),
+          ordinal: startedReasoningOrdinal,
+          state: providerState(event.providerMetadata)
+        });
+        return;
+      case "reasoning-delta":
+        const deltaReasoningOrdinal = yield* reasoning.append(event.id, event.text, providerState(event.providerMetadata));
+        yield* bus.publish(SessionEvent.Reasoning.Delta, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* currentAssistantMessageID(),
+          ordinal: deltaReasoningOrdinal,
+          delta: event.text
+        });
+        return;
+      case "reasoning-end":
+        yield* reasoning.end(event.id, providerState(event.providerMetadata));
+        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);
+        yield* bus.publish(SessionEvent.Tool.Input.Delta, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.assistantMessageID,
+          id: event.id,
+          delta: 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;
+        if (!tools.has(event.id))
+          yield* startToolInput(event);
+        const tool = tools.get(event.id);
+        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(SessionEvent.Tool.Called, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.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(SessionEvent.Tool.Failed, {
+            sessionID: input.sessionID,
+            assistantMessageID: tool.assistantMessageID,
+            id: event.id,
+            error: { type: "tool.execution", message: stringify(event.result.value) },
+            ...failureSnapshot(tool),
+            executed,
+            resultState
+          });
+          return;
+        }
+        yield* bus.publish(SessionEvent.Tool.Success, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.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(SessionEvent.Tool.Failed, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.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, tokens: exports_usage.tokens(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;
+    }
+  });
+  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(SessionEvent.Tool.Progress, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.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 = typeof result.content === "string" ? [{ type: "text", text: result.content }] : result.content === undefined ? [] : [...result.content];
+    if (content.length === 0)
+      return yield* Effect.die(new Error(`Tool execution has no content: ${id}`));
+    yield* bus.publish(SessionEvent.Tool.Success, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      content: [content[0], ...content.slice(1)],
+      ...result.metadata === undefined ? {} : { metadata: result.metadata },
+      executed: tool.providerExecuted
+    });
+  });
+  return {
+    publish,
+    progress,
+    toolExecution,
+    flush,
+    failAssistant,
+    failTool,
+    publishStepFailure,
+    failUnsettledTools,
+    hasProviderError: () => providerFailed,
+    record: () => ({
+      outputStarted,
+      providerFailed,
+      failure: stepFailure,
+      finish: stepSettlement,
+      calls: Array.from(tools, ([id, tool]) => ({
+        id,
+        name: tool.name,
+        called: tool.called,
+        settled: tool.settled,
+        providerExecuted: tool.providerExecuted
+      }))
+    }),
+    startAssistant,
+    assistantMessageID: assistantMessageIDForTool
+  };
+};
+
+export { createLLMEventPublisher };

package/dist/chunks/permission-9r0qzhnf.js

@@ -0,0 +1,34 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/vercel.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var VercelPlugin = define({
+  id: "opencode.provider.vercel",
+  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/vercel")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "http-referer": "https://opencode.ai/", "x-title": "opencode" };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "@ai-sdk/vercel")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/vercel"));
+      evt.sdk = mod.createVercel(evt.options);
+    }));
+  })
+});
+
+export { VercelPlugin };

package/dist/chunks/permission-9rdqpzw3.js

@@ -0,0 +1,115 @@
+import {
+  exports_instructions
+} from "./permission-q4r4pzs4.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  exports_state
+} from "./permission-wt193r4g.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/instruction-discovery.ts
+var exports_instruction_discovery = {};
+__export(exports_instruction_discovery, {
+  node: () => node,
+  layer: () => layer,
+  configured: () => configured,
+  Service: () => Service,
+  Options: () => Options,
+  InstructionDiscovery: () => exports_instruction_discovery,
+  File: () => File,
+  Event: () => Event
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+class File extends Schema.Class("InstructionDiscovery.File")({
+  path: AbsolutePath,
+  content: Schema.String
+}) {
+}
+var Files = Schema.Array(File);
+var key = exports_instructions.Key.make("core/instructions");
+var Event = {
+  Updated: exports_bus.ephemeral({ type: "instruction-discovery.updated", schema: {} })
+};
+var Options = Schema.Struct({
+  project: Schema.optional(Schema.Boolean)
+});
+
+class Service extends Context.Service()("@opencode/InstructionDiscovery") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const state = exports_state.create({
+    name: "instruction-discovery",
+    initial: () => ({ files: new Map, available: true }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.files.values()),
+      add: (file) => draft.files.set(file.path, new File(file)),
+      update: (path, update) => {
+        const current = draft.files.get(AbsolutePath.make(path));
+        if (!current)
+          return;
+        update(current);
+        current.path = AbsolutePath.make(path);
+      },
+      remove: (path) => draft.files.delete(AbsolutePath.make(path)),
+      unavailable: () => {
+        draft.available = false;
+      }
+    }),
+    finalize: () => bus.publish(Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const source = (value) => exports_instructions.make({
+    key,
+    codec: Schema.toCodecJson(Files),
+    read: Effect.succeed(value),
+    render: {
+      initial: render,
+      changed: (_previous, current) => `These instructions replace all previously loaded ambient instructions.
+
+${render(current)}`,
+      removed: () => "Previously loaded instructions no longer apply."
+    }
+  });
+  const list = Effect.fn("InstructionDiscovery.list")(function* () {
+    const current = state.get();
+    if (!current.available)
+      return exports_instructions.unavailable;
+    return Array.from(current.files.values());
+  });
+  return Service.of({
+    project: options?.project !== false,
+    transform: state.transform,
+    reload: state.reload,
+    list,
+    load: Effect.fn("InstructionDiscovery.load")(function* () {
+      const files = yield* list();
+      if (!Array.isArray(files))
+        return source(files);
+      return source(files.length === 0 ? exports_instructions.removed : files);
+    })
+  });
+}));
+function configured(options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [exports_bus.node]
+  });
+}
+var node = configured();
+function render(files) {
+  return files.map((file) => `Instructions from: ${file.path}
+${file.content}`).join(`
+
+`);
+}
+
+export { File, Event, Options, Service, layer, configured, node, exports_instruction_discovery };

package/dist/chunks/permission-9sdtsapf.js

@@ -0,0 +1,30 @@
+// src/database/migration/20260427172553_slow_nightmare.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260427172553_slow_nightmare",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_message\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_message_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_session_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_session_type_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_time_created_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_idx\` ON \`session_message\` (\`session_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_idx\` ON \`session_message\` (\`session_id\`,\`type\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_time_created_idx\` ON \`session_message\` (\`time_created\`);`);
+      yield* tx.run(`DROP TABLE \`session_entry\`;`);
+    });
+  }
+};
+var _20260427172553_slow_nightmare_default = migration;
+
+export { _20260427172553_slow_nightmare_default };

package/dist/chunks/permission-a02svayp.js

@@ -0,0 +1,10 @@
+// src/github-copilot/chat/openai-compatible-chat-options.ts
+import { z } from "zod/v4";
+var openaiCompatibleProviderOptions = z.object({
+  user: z.string().optional(),
+  reasoningEffort: z.string().optional(),
+  textVerbosity: z.string().optional(),
+  thinking_budget: z.number().optional()
+});
+
+export { openaiCompatibleProviderOptions };