@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-w4678h5q.js

@@ -0,0 +1,127 @@
+import {
+  make
+} from "./permission-706a4azd.js";
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/formatter.ts
+var exports_formatter = {};
+__export(exports_formatter, {
+  node: () => node,
+  Service: () => Service,
+  Formatter: () => exports_formatter
+});
+import { Context, Effect, Layer } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import path from "path";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Npm } from "@opencode-ai/util/npm";
+import { AppProcess } from "@opencode-ai/util/process";
+import { Global } from "@opencode-ai/util/global";
+class Service extends Context.Service()("@opencode/v2/Formatter") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const config = yield* exports_config.Service;
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const npm = yield* Npm.Service;
+  const processes = yield* AppProcess.Service;
+  const global = yield* Global.Service;
+  const commands = new Map;
+  let formatters = [];
+  const load = yield* Effect.cached(Effect.gen(function* () {
+    const configured = exports_config.latest(yield* config.entries(), "formatter");
+    if (!configured) {
+      yield* Effect.logInfo("all formatters are disabled");
+      return;
+    }
+    const builtIns = make({
+      directory: location.directory,
+      worktree: location.project.directory,
+      fs,
+      npm,
+      processes,
+      bin: global.bin
+    });
+    formatters = builtIns;
+    if (configured === true)
+      return;
+    for (const [name, entry] of Object.entries(configured)) {
+      const index = formatters.findIndex((formatter2) => formatter2.name === name);
+      if (entry.disabled) {
+        if (index !== -1)
+          formatters.splice(index, 1);
+        continue;
+      }
+      const builtIn = builtIns.find((formatter2) => formatter2.name === name);
+      const formatter = {
+        name,
+        extensions: entry.extensions ?? builtIn?.extensions ?? [],
+        environment: { ...builtIn?.environment, ...entry.environment },
+        enabled: builtIn && !entry.command ? builtIn.enabled : Effect.succeed(entry.command ? [...entry.command] : false)
+      };
+      if (index === -1)
+        formatters.push(formatter);
+      else
+        formatters[index] = formatter;
+    }
+  }).pipe(Effect.withSpan("Formatter.load")));
+  const command = Effect.fnUntraced(function* (formatter) {
+    const cached = commands.get(formatter.name);
+    if (cached !== undefined)
+      return cached;
+    const result = yield* formatter.enabled;
+    if (result !== false)
+      commands.set(formatter.name, result);
+    return result;
+  });
+  const file = Effect.fn("Formatter.file")(function* (filepath) {
+    yield* load;
+    const matching = formatters.filter((formatter) => formatter.extensions.includes(path.extname(filepath)));
+    for (const formatter of matching) {
+      const enabled = yield* command(formatter);
+      if (enabled === false)
+        continue;
+      const cmd = enabled.map((argument) => argument.replace("$FILE", filepath));
+      yield* Effect.logInfo("formatting file", { file: filepath, command: cmd });
+      const result = yield* processes.run(ChildProcess.make(cmd[0], cmd.slice(1), {
+        cwd: location.directory,
+        env: formatter.environment,
+        extendEnv: true,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore"
+      })).pipe(Effect.catch((error) => Effect.logError("failed to format file", {
+        file: filepath,
+        command: cmd,
+        error: error.message
+      }).pipe(Effect.as(undefined))));
+      if (!result)
+        continue;
+      if (result.exitCode === 0)
+        return true;
+      yield* Effect.logError("formatter exited unsuccessfully", {
+        file: filepath,
+        command: cmd,
+        exitCode: result.exitCode
+      });
+    }
+    return false;
+  });
+  return Service.of({ file });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_config.node, FSUtil.node, exports_location.node, Npm.node, AppProcess.node, Global.node]
+});
+
+export { Service, node, exports_formatter };

package/dist/chunks/permission-wd268jeg.js

@@ -0,0 +1,83 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/prompt-cache-diagnostics.ts
+var exports_prompt_cache_diagnostics = {};
+__export(exports_prompt_cache_diagnostics, {
+  snapshot: () => snapshot,
+  compare: () => compare,
+  PromptCacheDiagnostics: () => exports_prompt_cache_diagnostics
+});
+import { Hash } from "@opencode-ai/util/hash";
+var hash = (value) => Hash.sha256(JSON.stringify(value)).slice(0, 16);
+function snapshot(request) {
+  return {
+    settings: hash({
+      route: request.model.route.id,
+      provider: request.model.provider,
+      model: request.model.id,
+      modelDefaults: request.model.defaults,
+      compatibility: request.model.compatibility,
+      routeDefaults: {
+        generation: request.model.route.defaults.generation,
+        providerOptions: request.model.route.defaults.providerOptions,
+        http: request.model.route.defaults.http
+      },
+      generation: request.generation,
+      providerOptions: request.providerOptions,
+      http: request.http,
+      toolChoice: request.toolChoice,
+      cache: request.cache
+    }),
+    tools: request.tools.map((tool) => ({ label: tool.name, hash: hash(tool) })),
+    system: request.system.map((part, index) => ({ label: `system[${index}]`, hash: hash(part) })),
+    messages: request.messages.map((message, index) => ({
+      label: message.id ?? `${message.role}[${index}]`,
+      hash: hash(message)
+    }))
+  };
+}
+function compare(previous, current) {
+  if (!previous)
+    return { status: "initial" };
+  if (previous.settings !== current.settings)
+    return {
+      status: "changed",
+      component: "settings",
+      index: 0,
+      label: "model settings"
+    };
+  const tools = firstChange(previous.tools, current.tools, false);
+  if (tools)
+    return { status: "changed", component: "tools", ...tools };
+  const system = firstChange(previous.system, current.system, false);
+  if (system)
+    return { status: "changed", component: "system", ...system };
+  const messages = firstChange(previous.messages, current.messages, true);
+  if (messages)
+    return { status: "changed", component: "messages", ...messages };
+  if (previous.messages.length === current.messages.length)
+    return { status: "stable", messages: current.messages.length };
+  return {
+    status: "append-only",
+    previousMessages: previous.messages.length,
+    currentMessages: current.messages.length
+  };
+}
+function firstChange(previous, current, allowAppend) {
+  const index = previous.findIndex((entry, index2) => entry.hash !== current[index2]?.hash);
+  if (index >= 0)
+    return {
+      index,
+      label: current[index]?.label ?? previous[index]?.label ?? `entry[${index}]`
+    };
+  if (current.length === previous.length || allowAppend && current.length > previous.length)
+    return;
+  return {
+    index: previous.length,
+    label: current[previous.length]?.label ?? `entry[${previous.length}]`
+  };
+}
+
+export { snapshot, compare, exports_prompt_cache_diagnostics };

package/dist/chunks/permission-we2zmhe4.js

@@ -0,0 +1,74 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/snowflake-cortex.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+function cortexFetch(upstream = fetch) {
+  return async (url, init) => {
+    if (init?.body && typeof init.body === "string") {
+      try {
+        const body = JSON.parse(init.body);
+        if ("max_tokens" in body) {
+          body.max_completion_tokens = body.max_tokens;
+          delete body.max_tokens;
+          init = { ...init, body: JSON.stringify(body) };
+        }
+      } catch {}
+    }
+    const response = await upstream(url, init);
+    if (!response.ok && response.status === 400) {
+      try {
+        const errorData = await response.clone().json();
+        if (String(errorData.message || errorData.error || "").toLowerCase().includes("conversation complete")) {
+          return new Response(JSON.stringify({ choices: [{ finish_reason: "stop", message: { content: "", role: "assistant" } }] }), { status: 200, headers: new Headers({ "content-type": "application/json" }) });
+        }
+      } catch {}
+    }
+    if (response.body && response.headers.get("content-type")?.includes("text/event-stream")) {
+      const reader = response.body.getReader();
+      const encoder = new TextEncoder;
+      const decoder = new TextDecoder;
+      const stream = new ReadableStream({
+        async pull(ctrl) {
+          const { done, value } = await reader.read();
+          if (done) {
+            ctrl.close();
+            return;
+          }
+          ctrl.enqueue(encoder.encode(decoder.decode(value, { stream: true }).replace(/"role"\s*:\s*""/g, '"role":"assistant"')));
+        },
+        cancel() {
+          reader.cancel();
+        }
+      });
+      return new Response(stream, { headers: response.headers, status: response.status });
+    }
+    return response;
+  };
+}
+var SnowflakeCortexPlugin = define({
+  id: "opencode.provider.snowflake-cortex",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== exports_provider.ID.make("snowflake-cortex"))
+        return;
+      const token = process.env.SNOWFLAKE_CORTEX_TOKEN ?? process.env.SNOWFLAKE_CORTEX_PAT ?? (typeof evt.options.token === "string" ? evt.options.token : undefined) ?? (typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined);
+      const upstream = typeof evt.options.fetch === "function" ? evt.options.fetch : undefined;
+      if (evt.options.includeUsage !== false)
+        evt.options.includeUsage = true;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"));
+      evt.sdk = mod.createOpenAICompatible({
+        ...evt.options,
+        ...token ? { apiKey: token } : {},
+        fetch: cortexFetch(upstream)
+      });
+    }));
+  })
+});
+
+export { cortexFetch, SnowflakeCortexPlugin };

package/dist/chunks/permission-wf37p1a1.js

@@ -0,0 +1,266 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/promise.ts
+var exports_promise = {};
+__export(exports_promise, {
+  fromPromise: () => fromPromise,
+  PluginPromise: () => exports_promise
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Integration } from "@opencode-ai/schema/integration";
+import { Location } from "@opencode-ai/schema/location";
+import { Model } from "@opencode-ai/schema/model";
+import { Provider } from "@opencode-ai/schema/provider";
+import { AbsolutePath } from "@opencode-ai/schema/schema";
+import { Session } from "@opencode-ai/schema/session";
+import { SessionMessage } from "@opencode-ai/schema/session-message";
+import { Skill } from "@opencode-ai/schema/skill";
+import { Workspace } from "@opencode-ai/schema/workspace";
+import { WebSearch } from "@opencode-ai/schema/websearch";
+import { DateTime, Effect, Scope, Stream } from "effect";
+function fromPromise(plugin) {
+  return define({
+    id: plugin.id,
+    effect: (host) => Effect.gen(function* () {
+      const scope = yield* Scope.Scope;
+      const context = yield* Effect.context();
+      const register = (effect) => Effect.runPromiseWith(context)(Scope.provide(scope)(effect)).then((registration) => ({
+        dispose: () => Effect.runPromiseWith(context)(registration.dispose)
+      }));
+      const run = (effect) => Effect.runPromiseWith(context)(effect).then(wire);
+      const transform = (domain) => (callback) => register(domain.transform((draft) => {
+        callback(draft);
+      }));
+      const context2 = {
+        app: host.app,
+        options: host.options,
+        agent: {
+          get: (input) => run(host.agent.get({ ...input, agentID: Agent.ID.make(input.agentID) })),
+          list: (input) => run(host.agent.list(input)),
+          transform: transform(host.agent),
+          reload: () => run(host.agent.reload())
+        },
+        aisdk: {
+          hook: (name, callback) => register(host.aisdk.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event)))))
+        },
+        catalog: {
+          provider: {
+            list: (input) => run(host.catalog.provider.list(input)),
+            get: (input) => run(host.catalog.provider.get({ ...input, providerID: Provider.ID.make(input.providerID) }))
+          },
+          model: {
+            list: (input) => run(host.catalog.model.list(input)),
+            default: (input) => run(host.catalog.model.default(input)).then((result) => ({ ...result, data: result.data ?? null }))
+          },
+          transform: transform(host.catalog),
+          reload: () => run(host.catalog.reload())
+        },
+        command: {
+          list: (input) => run(host.command.list(input)),
+          transform: transform(host.command),
+          reload: () => run(host.command.reload())
+        },
+        event: {
+          subscribe: () => Stream.toAsyncIterable(host.event.subscribe().pipe(Stream.map(wireEvent)))
+        },
+        integration: {
+          list: (input) => run(host.integration.list(input)),
+          get: (input) => run(host.integration.get({ ...input, integrationID: Integration.ID.make(input.integrationID) })).then((result) => ({ ...result, data: result.data ?? null })),
+          connect: {
+            key: (input) => run(host.integration.connect.key({ ...input, integrationID: Integration.ID.make(input.integrationID) }))
+          },
+          oauth: {
+            connect: (input) => run(host.integration.oauth.connect({
+              ...input,
+              integrationID: Integration.ID.make(input.integrationID),
+              methodID: Integration.MethodID.make(input.methodID)
+            })),
+            status: (input) => run(host.integration.oauth.status({
+              ...input,
+              integrationID: Integration.ID.make(input.integrationID),
+              attemptID: Integration.AttemptID.make(input.attemptID)
+            })),
+            complete: (input) => run(host.integration.oauth.complete({
+              ...input,
+              integrationID: Integration.ID.make(input.integrationID),
+              attemptID: Integration.AttemptID.make(input.attemptID)
+            })),
+            cancel: (input) => run(host.integration.oauth.cancel({
+              ...input,
+              integrationID: Integration.ID.make(input.integrationID),
+              attemptID: Integration.AttemptID.make(input.attemptID)
+            }))
+          },
+          command: {
+            connect: (input) => run(host.integration.command.connect({
+              ...input,
+              integrationID: Integration.ID.make(input.integrationID),
+              methodID: Integration.MethodID.make(input.methodID)
+            })),
+            status: (input) => run(host.integration.command.status({
+              ...input,
+              integrationID: Integration.ID.make(input.integrationID),
+              attemptID: Integration.AttemptID.make(input.attemptID)
+            })),
+            cancel: (input) => run(host.integration.command.cancel({
+              ...input,
+              integrationID: Integration.ID.make(input.integrationID),
+              attemptID: Integration.AttemptID.make(input.attemptID)
+            }))
+          },
+          transform: (callback) => register(host.integration.transform((draft) => callback({
+            list: draft.list,
+            get: draft.get,
+            update: draft.update,
+            remove: draft.remove,
+            method: {
+              list: draft.method.list,
+              update: (input) => {
+                if (!("authorize" in input))
+                  return draft.method.update(input);
+                const refresh = input.refresh;
+                draft.method.update({
+                  ...input,
+                  authorize: (answer) => Effect.promise(() => input.authorize(answer)).pipe(Effect.map((authorization) => authorization.mode === "auto" ? {
+                    ...authorization,
+                    callback: Effect.promise(() => authorization.callback)
+                  } : {
+                    ...authorization,
+                    callback: (code) => Effect.promise(() => authorization.callback(code))
+                  })),
+                  refresh: refresh === undefined ? undefined : (credential) => Effect.promise(() => refresh(credential))
+                });
+              },
+              remove: draft.method.remove
+            }
+          }))),
+          reload: () => run(host.integration.reload()),
+          connection: {
+            active: (id) => Effect.runPromiseWith(context)(host.integration.connection.active(id)),
+            resolve: (connection) => Effect.runPromiseWith(context)(host.integration.connection.resolve(connection))
+          }
+        },
+        plugin: {
+          list: (input) => run(host.plugin.list(input))
+        },
+        reference: {
+          list: (input) => run(host.reference.list(input)),
+          transform: transform(host.reference),
+          reload: () => run(host.reference.reload())
+        },
+        skill: {
+          list: (input) => run(host.skill.list(input)),
+          transform: transform(host.skill),
+          reload: () => run(host.skill.reload())
+        },
+        tool: {
+          transform: (callback) => register(host.tool.transform((draft) => callback({
+            add: (tool) => draft.add({
+              ...tool,
+              execute: (input, context3) => executePromiseTool(tool, input, context3)
+            })
+          }))),
+          hook: (name, callback) => register(host.tool.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event)))))
+        },
+        websearch: {
+          providers: (input) => run(host.websearch.providers(input)),
+          query: (input) => run(host.websearch.query({
+            ...input,
+            providerID: input.providerID === undefined ? undefined : WebSearch.ID.make(input.providerID)
+          })),
+          reload: () => run(host.websearch.reload()),
+          transform: (callback) => register(host.websearch.transform((draft) => {
+            callback({
+              add: (definition) => draft.add({
+                id: definition.id,
+                name: definition.name,
+                execute: (input) => attempt((signal) => definition.execute(input, { signal }))
+              }),
+              default: draft.default
+            });
+          }))
+        },
+        session: {
+          hook: (name, callback) => register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+          create: (input) => run(host.session.create(input === undefined ? undefined : {
+            id: input.id == null ? undefined : Session.ID.make(input.id),
+            agent: input.agent == null ? undefined : Agent.ID.make(input.agent),
+            model: input.model == null ? undefined : model(input.model),
+            location: input.location == null ? undefined : Location.Ref.make({
+              directory: AbsolutePath.make(input.location.directory),
+              workspaceID: input.location.workspaceID === undefined ? undefined : Workspace.ID.make(input.location.workspaceID)
+            })
+          })),
+          get: (input) => run(host.session.get({ sessionID: Session.ID.make(input.sessionID) })),
+          prompt: (input) => run(host.session.prompt({
+            ...input,
+            sessionID: Session.ID.make(input.sessionID),
+            id: input.id == null ? undefined : SessionMessage.ID.make(input.id),
+            skills: input.skills?.map((skill) => ({ ...skill, id: Skill.ID.make(skill.id) })),
+            delivery: input.delivery ?? undefined,
+            resume: input.resume ?? undefined
+          })),
+          generate: (input) => run(host.session.generate({ sessionID: Session.ID.make(input.sessionID), prompt: input.prompt })),
+          command: (input) => run(host.session.command({
+            ...input,
+            sessionID: Session.ID.make(input.sessionID),
+            id: input.id == null ? undefined : SessionMessage.ID.make(input.id),
+            agent: input.agent == null ? undefined : Agent.ID.make(input.agent),
+            model: input.model == null ? undefined : model(input.model),
+            skills: input.skills?.map((skill) => ({ ...skill, id: Skill.ID.make(skill.id) })),
+            arguments: input.arguments ?? undefined,
+            delivery: input.delivery ?? undefined,
+            resume: input.resume ?? undefined
+          })),
+          synthetic: (input) => run(host.session.synthetic({
+            ...input,
+            sessionID: Session.ID.make(input.sessionID),
+            id: input.id == null ? undefined : SessionMessage.ID.make(input.id),
+            description: input.description ?? undefined,
+            delivery: input.delivery ?? undefined,
+            resume: input.resume ?? undefined
+          })),
+          interrupt: (input) => run(host.session.interrupt({ sessionID: Session.ID.make(input.sessionID) }))
+        },
+        shell: {
+          hook: (name, callback) => register(host.shell.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event)))))
+        }
+      };
+      const cleanup = yield* Effect.promise(() => Promise.resolve(plugin.setup(context2)));
+      if (!cleanup)
+        return;
+      yield* Effect.addFinalizer(() => Effect.promise(() => Promise.resolve(cleanup())));
+    })
+  });
+}
+function attempt(evaluate) {
+  return Effect.tryPromise({ try: evaluate, catch: (cause) => cause });
+}
+function model(input) {
+  return Model.Ref.make({
+    id: Model.ID.make(input.id),
+    providerID: Provider.ID.make(input.providerID),
+    variant: input.variant === undefined ? undefined : Model.VariantID.make(input.variant)
+  });
+}
+function wire(value) {
+  if (DateTime.isDateTime(value))
+    return DateTime.toEpochMillis(value);
+  if (Array.isArray(value))
+    return value.map(wire);
+  if (typeof value !== "object" || value === null)
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, wire(item)]));
+}
+function wireEvent(value) {
+  return wire(value);
+}
+var executePromiseTool = (tool, input, context) => Effect.promise(() => tool.execute(input, {
+  ...context,
+  progress: (update) => Effect.runPromise(context.progress(update))
+}));
+
+export { fromPromise, exports_promise };

package/dist/chunks/permission-wj4sxzqa.js

@@ -0,0 +1,38 @@
+// src/github-copilot/responses/tool/file-search.ts
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var comparisonFilterSchema = z.object({
+  key: z.string(),
+  type: z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+  value: z.union([z.string(), z.number(), z.boolean()])
+});
+var compoundFilterSchema = z.object({
+  type: z.enum(["and", "or"]),
+  filters: z.array(z.union([comparisonFilterSchema, z.lazy(() => compoundFilterSchema)]))
+});
+var fileSearchArgsSchema = z.object({
+  vectorStoreIds: z.array(z.string()),
+  maxNumResults: z.number().optional(),
+  ranking: z.object({
+    ranker: z.string().optional(),
+    scoreThreshold: z.number().optional()
+  }).optional(),
+  filters: z.union([comparisonFilterSchema, compoundFilterSchema]).optional()
+});
+var fileSearchOutputSchema = z.object({
+  queries: z.array(z.string()),
+  results: z.array(z.object({
+    attributes: z.record(z.string(), z.unknown()),
+    fileId: z.string(),
+    filename: z.string(),
+    score: z.number(),
+    text: z.string()
+  })).nullable()
+});
+var fileSearch = createProviderToolFactoryWithOutputSchema({
+  id: "openai.file_search",
+  inputSchema: z.object({}),
+  outputSchema: fileSearchOutputSchema
+});
+
+export { fileSearchArgsSchema, fileSearchOutputSchema, fileSearch };

package/dist/chunks/permission-wmxdh12w.js

@@ -0,0 +1,13 @@
+import {
+  Timestamps
+} from "./permission-sem2g21k.js";
+
+// src/kv/sql.ts
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+var KVTable = sqliteTable("kv", {
+  key: text().primaryKey(),
+  value: text({ mode: "json" }).$type().notNull(),
+  ...Timestamps
+});
+
+export { KVTable };

package/dist/chunks/permission-wps8gh8n.js

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