@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-5gvndtda.js

@@ -0,0 +1,205 @@
+import {
+  exports_integration
+} from "./location-mutation-67ww7a6n.js";
+import {
+  exports_state
+} from "./location-mutation-wt193r4g.js";
+import {
+  exports_model
+} from "./location-mutation-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/catalog.ts
+var exports_catalog = {};
+__export(exports_catalog, {
+  node: () => node,
+  Service: () => Service,
+  Event: () => Event,
+  Catalog: () => exports_catalog
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Array, Context, Effect, Layer, Order, pipe } from "effect";
+import { Catalog } from "@opencode-ai/schema/catalog";
+import { Event } from "@opencode-ai/schema/catalog";
+
+class Service extends Context.Service()("@opencode/Catalog") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const integrations = yield* exports_integration.Service;
+  const available = (provider, integration) => {
+    if (provider.activation === "disabled")
+      return false;
+    if (provider.activation === "enabled")
+      return true;
+    if (integration?.connections.length)
+      return true;
+    return provider.integrationID === undefined && !integration;
+  };
+  const projectModel = (model, provider) => {
+    return {
+      ...model,
+      package: model.package ?? provider.package,
+      settings: exports_provider.mergeOverlay(provider.settings, model.settings),
+      headers: exports_provider.mergeHeaders(provider.headers, model.headers),
+      body: exports_provider.mergeOverlay(provider.body, model.body)
+    };
+  };
+  const state = exports_state.create({
+    name: "catalog",
+    initial: () => ({ providers: new Map }),
+    draft: (draft) => {
+      const result2 = {
+        provider: {
+          list: () => Array.fromIterable(draft.providers.values()),
+          get: (providerID) => draft.providers.get(providerID),
+          update: (providerID, fn) => {
+            let current = draft.providers.get(providerID);
+            if (!current) {
+              current = {
+                provider: exports_provider.Info.empty(providerID),
+                models: new Map
+              };
+              draft.providers.set(providerID, current);
+            }
+            fn(current.provider);
+          },
+          remove: (providerID) => {
+            draft.providers.delete(providerID);
+          }
+        },
+        model: {
+          get: (providerID, modelID) => draft.providers.get(providerID)?.models.get(modelID),
+          update: (providerID, modelID, fn) => {
+            let record = draft.providers.get(providerID);
+            if (!record) {
+              record = {
+                provider: exports_provider.Info.empty(providerID),
+                models: new Map
+              };
+              draft.providers.set(providerID, record);
+            }
+            const model = record.models.get(modelID) ?? exports_model.Info.default(providerID, modelID);
+            if (!record.models.has(modelID))
+              record.models.set(modelID, model);
+            fn(model);
+            model.id = modelID;
+            model.providerID = providerID;
+          },
+          remove: (providerID, modelID) => {
+            draft.providers.get(providerID)?.models.delete(modelID);
+          },
+          default: {
+            get: () => draft.defaultModel,
+            set: (providerID, modelID) => {
+              draft.defaultModel = { providerID, modelID };
+            }
+          }
+        }
+      };
+      return result2;
+    },
+    finalize: Effect.fn("Catalog.finalize")(function* (catalog) {
+      yield* bus.publish(Catalog.Event.Updated, {});
+    })
+  });
+  const result = {
+    transform: state.transform,
+    reload: state.reload,
+    provider: {
+      get: Effect.fn("Catalog.provider.get")(function* (providerID) {
+        return state.get().providers.get(providerID)?.provider;
+      }),
+      all: Effect.fn("Catalog.provider.all")(function* () {
+        return Array.fromIterable(state.get().providers.values()).map((record) => record.provider);
+      }),
+      available: Effect.fn("Catalog.provider.available")(function* () {
+        const active = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]));
+        return (yield* result.provider.all()).filter((provider) => available(provider, active.get(provider.integrationID ?? exports_integration.ID.make(provider.id))));
+      })
+    },
+    model: {
+      get: Effect.fn("Catalog.model.get")(function* (providerID, modelID) {
+        const record = state.get().providers.get(providerID);
+        if (!record)
+          return;
+        const model = record.models.get(modelID);
+        return model && projectModel(model, record.provider);
+      }),
+      all: Effect.fn("Catalog.model.all")(function* () {
+        return pipe(Array.fromIterable(state.get().providers.values()), Array.flatMap((record) => {
+          return Array.fromIterable(record.models.values()).map((model) => projectModel(model, record.provider));
+        }), Array.sortWith((item) => item.time.released, Order.flip(Order.Number)));
+      }),
+      available: Effect.fn("Catalog.model.available")(function* () {
+        const providers = new Set((yield* result.provider.available()).map((provider) => provider.id));
+        const models = [];
+        for (const record of state.get().providers.values()) {
+          if (!providers.has(record.provider.id))
+            continue;
+          for (const model of record.models.values()) {
+            if (!model.enabled)
+              continue;
+            models.push(projectModel(model, record.provider));
+          }
+        }
+        return pipe(models, Array.sortWith((item) => item.time.released, Order.flip(Order.Number)));
+      }),
+      default: Effect.fn("Catalog.model.default")(function* () {
+        const defaultModel = state.get().defaultModel;
+        if (defaultModel) {
+          const provider = yield* result.provider.get(defaultModel.providerID);
+          if (provider && (yield* result.provider.available()).some((item) => item.id === provider.id)) {
+            const model = yield* result.model.get(defaultModel.providerID, defaultModel.modelID);
+            if (model?.enabled)
+              return model;
+          }
+        }
+        return (yield* result.model.available())[0];
+      }),
+      small: Effect.fn("Catalog.model.small")(function* (providerID) {
+        const record = state.get().providers.get(providerID);
+        if (!record)
+          return;
+        const provider = record.provider;
+        if (providerID === exports_provider.ID.azure) {
+          return;
+        }
+        if (providerID === exports_provider.ID.opencode) {
+          const gpt5Nano = record.models.get(exports_model.ID.make("gpt-5-nano"));
+          if (gpt5Nano?.enabled && gpt5Nano.status === "active")
+            return projectModel(gpt5Nano, provider);
+        }
+        const candidates = pipe(Array.fromIterable(record.models.values()), Array.filter((model) => model.providerID === providerID && model.enabled && model.status === "active" && model.capabilities.input.some((item) => item.startsWith("text")) && model.capabilities.output.some((item) => item.startsWith("text"))), Array.map((model) => ({
+          model,
+          cost: model.cost[0] ? model.cost[0].input + model.cost[0].output : 999,
+          age: (Date.now() - model.time.released) / (1000 * 60 * 60 * 24 * 30),
+          small: SMALL_MODEL_RE.test(`${model.id} ${model.family ?? ""} ${model.name}`.toLowerCase())
+        })), Array.filter((item) => item.cost > 0 && item.age <= 18));
+        const pick = (items) => {
+          if (!Array.isReadonlyArrayNonEmpty(items))
+            return;
+          const maxCost = Math.max(...items.map((item) => item.cost), 0.01);
+          const maxAge = Math.max(...items.map((item) => item.age), 0.01);
+          const selected = Array.min(items, Order.mapInput(Order.Number, (item) => item.cost / maxCost * 0.8 + item.age / maxAge * 0.2));
+          return projectModel(selected.model, provider);
+        };
+        const small = candidates.filter((item) => item.small);
+        return pick(small.length > 0 ? small : candidates);
+      })
+    }
+  };
+  return Service.of(result);
+}));
+var SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/;
+var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node, exports_integration.node] });
+
+export { Service, node, exports_catalog, Event };

package/dist/chunks/location-mutation-5kqga4an.js

@@ -0,0 +1,142 @@
+import {
+  webSearchPreviewArgsSchema
+} from "./location-mutation-7n9qwqk4.js";
+import {
+  imageGenerationArgsSchema
+} from "./location-mutation-4b2tz2m9.js";
+import {
+  codeInterpreterArgsSchema
+} from "./location-mutation-5a5ch9ts.js";
+import {
+  fileSearchArgsSchema
+} from "./location-mutation-wj4sxzqa.js";
+import {
+  webSearchArgsSchema
+} from "./location-mutation-gy500k2r.js";
+
+// src/github-copilot/responses/openai-responses-prepare-tools.ts
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+function prepareResponsesTools({
+  tools,
+  toolChoice,
+  strictJsonSchema
+}) {
+  tools = tools?.length ? tools : undefined;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+  const openaiTools = [];
+  for (const tool of tools) {
+    switch (tool.type) {
+      case "function":
+        openaiTools.push({
+          type: "function",
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          strict: strictJsonSchema
+        });
+        break;
+      case "provider": {
+        switch (tool.id) {
+          case "openai.file_search": {
+            const args = fileSearchArgsSchema.parse(tool.args);
+            openaiTools.push({
+              type: "file_search",
+              vector_store_ids: args.vectorStoreIds,
+              max_num_results: args.maxNumResults,
+              ranking_options: args.ranking ? {
+                ranker: args.ranking.ranker,
+                score_threshold: args.ranking.scoreThreshold
+              } : undefined,
+              filters: args.filters
+            });
+            break;
+          }
+          case "openai.local_shell": {
+            openaiTools.push({
+              type: "local_shell"
+            });
+            break;
+          }
+          case "openai.web_search_preview": {
+            const args = webSearchPreviewArgsSchema.parse(tool.args);
+            openaiTools.push({
+              type: "web_search_preview",
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation
+            });
+            break;
+          }
+          case "openai.web_search": {
+            const args = webSearchArgsSchema.parse(tool.args);
+            openaiTools.push({
+              type: "web_search",
+              filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : undefined,
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation
+            });
+            break;
+          }
+          case "openai.code_interpreter": {
+            const args = codeInterpreterArgsSchema.parse(tool.args);
+            openaiTools.push({
+              type: "code_interpreter",
+              container: args.container == null ? { type: "auto", file_ids: undefined } : typeof args.container === "string" ? args.container : { type: "auto", file_ids: args.container.fileIds }
+            });
+            break;
+          }
+          case "openai.image_generation": {
+            const args = imageGenerationArgsSchema.parse(tool.args);
+            openaiTools.push({
+              type: "image_generation",
+              background: args.background,
+              input_fidelity: args.inputFidelity,
+              input_image_mask: args.inputImageMask ? {
+                file_id: args.inputImageMask.fileId,
+                image_url: args.inputImageMask.imageUrl
+              } : undefined,
+              model: args.model,
+              moderation: args.moderation,
+              partial_images: args.partialImages,
+              quality: args.quality,
+              output_compression: args.outputCompression,
+              output_format: args.outputFormat,
+              size: args.size
+            });
+            break;
+          }
+        }
+        break;
+      }
+      default:
+        toolWarnings.push({ type: "unsupported", feature: "tool type" });
+        break;
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiTools, toolChoice: undefined, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiTools,
+        toolChoice: toolChoice.toolName === "code_interpreter" || toolChoice.toolName === "file_search" || toolChoice.toolName === "image_generation" || toolChoice.toolName === "web_search_preview" || toolChoice.toolName === "web_search" ? { type: toolChoice.toolName } : { type: "function", name: toolChoice.toolName },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+export { prepareResponsesTools };

package/dist/chunks/location-mutation-5p2sx24b.js

@@ -0,0 +1,56 @@
+import {
+  exports_model
+} from "./location-mutation-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/variant.ts
+var exports_variant = {};
+__export(exports_variant, {
+  generate: () => generate,
+  VariantPlugin: () => exports_variant,
+  Plugin: () => Plugin
+});
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var Plugin = define({
+  id: "opencode.variant",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((catalog) => {
+      for (const record of catalog.provider.list()) {
+        for (const model of record.models.values()) {
+          catalog.model.update(model.providerID, model.id, (draft) => {
+            const generated = generate(draft, record.provider);
+            if (generated.length === 0)
+              return;
+            const variants = draft.variants ?? [];
+            const explicit = new Map(variants.map((variant) => [variant.id, variant]));
+            const generatedIDs = new Set(generated.map((variant) => variant.id));
+            draft.variants = [
+              ...generated.map((variant) => explicit.get(variant.id) ?? variant),
+              ...variants.filter((variant) => !generatedIDs.has(variant.id))
+            ];
+          });
+        }
+      }
+    });
+  })
+});
+function generate(model, provider) {
+  const packageName = model.package ?? provider?.package;
+  if (!exports_provider.isAISDK(packageName) || exports_provider.packageName(packageName) !== "@ai-sdk/openai-compatible")
+    return [];
+  const ids = `${model.id} ${model.modelID ?? ""}`.toLowerCase();
+  if (!["glm-5.2", "glm-5-2", "glm-5p2"].some((name) => ids.includes(name)))
+    return [];
+  return ["high", "max"].map((id) => ({
+    id: exports_model.VariantID.make(id),
+    settings: { reasoningEffort: id }
+  }));
+}
+
+export { Plugin, generate, exports_variant };

package/dist/chunks/location-mutation-5pfeh60c.js

@@ -0,0 +1,154 @@
+import {
+  Failed,
+  NotFound,
+  WrongKind
+} from "./location-mutation-zthe9zqc.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/environment/exec-defaults.ts
+var exports_exec_defaults = {};
+__export(exports_exec_defaults, {
+  execDefaults: () => execDefaults,
+  EnvironmentExecDefaults: () => exports_exec_defaults
+});
+import { Effect, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { collectStream } from "@opencode-ai/util/process";
+var MAX_DATA_BYTES = 64 * 1024 * 1024;
+var MAX_ERROR_BYTES = 64 * 1024;
+var NOT_FOUND = 44;
+var WRONG_KIND = 45;
+var FAILED = 46;
+var TAB = "\t";
+var loadMetadata = (flags = "") => `
+metadata=$(stat ${flags} -c '%F${TAB}%s${TAB}%Y' -- "$1" 2>&1) || {
+  case "$metadata" in
+    *'No such file or directory'*|*'Not a directory'*) exit ${NOT_FOUND} ;;
+    *) printf '%s' "$metadata" >&2; exit ${FAILED} ;;
+  esac
+}
+`;
+var statScript = `
+${loadMetadata()}
+printf '%s
+' "$metadata"
+`;
+var readScript = `
+${loadMetadata("-L")}
+kind=\${metadata%%${TAB}*}
+if [ "$kind" != 'regular file' ] && [ "$kind" != 'regular empty file' ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+printf '%s
+' "$metadata"
+if [ "$2" = range ]; then
+  dd if="$1" iflag=skip_bytes,count_bytes skip="$3" count="$4" status=none
+else
+  cat -- "$1"
+fi
+`;
+var listScript = `
+${loadMetadata("-L")}
+kind=\${metadata%%${TAB}*}
+if [ "$kind" != directory ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+find -H "$1" -mindepth 1 -maxdepth 1 -printf '%y\\0%f\\0'
+`;
+var moveScript = `
+${loadMetadata()}
+mv -- "$1" "$2"
+`;
+var execDefaults = (spawner) => {
+  const run = (path, script, args = [], stdin) => Effect.scoped(Effect.gen(function* () {
+    const command = ChildProcess.make("sh", ["-c", script, "sh", path, ...args], {
+      env: { LC_ALL: "C" },
+      extendEnv: true,
+      stdin: stdin === undefined ? undefined : Stream.make(stdin)
+    });
+    const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed({ path, cause })));
+    const [stdout, stderr, exitCode] = yield* Effect.all([
+      collectStream(handle.stdout, MAX_DATA_BYTES),
+      collectStream(handle.stderr, MAX_ERROR_BYTES),
+      handle.exitCode
+    ], { concurrency: "unbounded" }).pipe(Effect.mapError((cause) => new Failed({ path, cause })));
+    if (stdout.truncated || stderr.truncated) {
+      return yield* new Failed({ path, cause: new Error("Process output exceeded its collection limit") });
+    }
+    return { exitCode, stdout: stdout.buffer, stderr: stderr.buffer };
+  }));
+  const classify = (path, result, success) => {
+    if (result.exitCode === 0)
+      return Effect.sync(() => success(result.stdout));
+    if (result.exitCode === NOT_FOUND)
+      return Effect.fail(new NotFound({ path }));
+    if (result.exitCode === WRONG_KIND) {
+      return Effect.fail(new WrongKind({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }));
+    }
+    return Effect.fail(processFailure(path, result));
+  };
+  const complete = (path, result) => result.exitCode === 0 ? Effect.void : Effect.fail(processFailure(path, result));
+  return {
+    stat: (path) => run(path, statScript).pipe(Effect.flatMap((result) => classifyPlain(path, result, parseInfo))),
+    read: (path, range) => run(path, readScript, range === undefined ? ["whole"] : ["range", String(range.offset), String(range.length)]).pipe(Effect.flatMap((result) => classify(path, result, (stdout) => {
+      const newline = stdout.indexOf(10);
+      if (newline < 0)
+        throw new Error("Missing read metadata header");
+      return {
+        info: parseInfo(stdout.slice(0, newline)),
+        bytes: stdout.slice(newline + 1)
+      };
+    }))),
+    write: (path, bytes) => run(path, `mkdir -p "$(dirname "$1")" && cat > "$1"`, [], bytes).pipe(Effect.flatMap((result) => complete(path, result))),
+    list: (path) => run(path, listScript).pipe(Effect.flatMap((result) => classify(path, result, parseList))),
+    remove: (path) => run(path, `rm -rf -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
+    move: (from, to) => run(from, moveScript, [to]).pipe(Effect.flatMap((result) => classifyPlain(from, result, () => {
+      return;
+    }))),
+    mkdir: (path) => run(path, `mkdir -p -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result)))
+  };
+};
+var classifyPlain = (path, result, success) => {
+  if (result.exitCode === 0)
+    return Effect.sync(() => success(result.stdout));
+  if (result.exitCode === NOT_FOUND)
+    return Effect.fail(new NotFound({ path }));
+  return Effect.fail(processFailure(path, result));
+};
+var processFailure = (path, result) => new Failed({
+  path,
+  cause: new Error(new TextDecoder().decode(result.stderr).trim() || `Process exited with code ${result.exitCode}`)
+});
+var parseInfo = (bytes) => {
+  const [rawType, rawSize, rawMtime] = new TextDecoder().decode(bytes).trim().split(TAB);
+  const size = Number(rawSize);
+  const mtimeMs = Number(rawMtime) * 1000;
+  if (!rawType || !Number.isFinite(size) || !Number.isFinite(mtimeMs))
+    throw new Error("Invalid stat output");
+  return { type: parseType(rawType), size, mtimeMs };
+};
+var parseType = (value) => {
+  if (value === "regular file" || value === "regular empty file" || value === "f")
+    return "file";
+  if (value === "directory" || value === "d")
+    return "directory";
+  if (value === "symbolic link" || value === "l")
+    return "symlink";
+  return "other";
+};
+var parseList = (bytes) => {
+  const fields = new TextDecoder().decode(bytes).split("\x00");
+  fields.pop();
+  if (fields.length % 2 !== 0)
+    throw new Error("Invalid find output");
+  return Array.from({ length: fields.length / 2 }, (_, index) => ({
+    name: fields[index * 2 + 1],
+    type: parseType(fields[index * 2])
+  }));
+};
+
+export { execDefaults, exports_exec_defaults };

package/dist/chunks/location-mutation-5rs65q6p.js

@@ -0,0 +1,65 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/database/sqlite.ts
+var exports_sqlite = {};
+__export(exports_sqlite, {
+  makeConnection: () => makeConnection,
+  makeClient: () => makeClient,
+  Sqlite: () => exports_sqlite,
+  Native: () => Native
+});
+import { Context, Effect, Fiber, Scope, Semaphore, Stream } from "effect";
+import { identity } from "effect/Function";
+import { SqlClient, Statement } from "effect/unstable/sql";
+
+class Native extends Context.Service()("@opencode-ai/core/database/SqliteNative") {
+}
+var makeConnection = (run, runValues, extensions) => identity({
+  execute(query, params, transformRows) {
+    return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params);
+  },
+  executeRaw(query, params) {
+    return run(query, params);
+  },
+  executeValues(query, params) {
+    return runValues(query, params);
+  },
+  executeValuesUnprepared(query, params) {
+    return runValues(query, params);
+  },
+  executeUnprepared(query, params, transformRows) {
+    return this.execute(query, params, transformRows);
+  },
+  executeStream() {
+    return Stream.die("executeStream not implemented");
+  },
+  ...extensions
+});
+var makeClient = (options, connection, typeId, extensions) => Effect.gen(function* () {
+  const semaphore = yield* Semaphore.make(1);
+  const acquirer = semaphore.withPermits(1)(Effect.succeed(connection));
+  const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
+    const fiber = Fiber.getCurrent();
+    const scope = Context.getUnsafe(fiber.context, Scope.Scope);
+    return Effect.as(Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))), connection);
+  });
+  const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames).array : undefined;
+  return Object.assign(yield* SqlClient.make({
+    acquirer,
+    compiler: Statement.makeCompilerSqlite(options.transformQueryNames),
+    transactionAcquirer,
+    spanAttributes: [
+      ...options.spanAttributes ? Object.entries(options.spanAttributes) : [],
+      ["db.system.name", "sqlite"]
+    ],
+    transformRows
+  }), {
+    [typeId]: typeId,
+    config: options,
+    ...extensions(acquirer)
+  });
+});
+
+export { Native, makeConnection, makeClient, exports_sqlite };