@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-3seenrp7.js

@@ -0,0 +1,162 @@
+import {
+  mergeOverlay2,
+  mergeHeaders2
+} from "./repository-pye8sh6e.js";
+import {
+  latest2,
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  observe2
+} from "./repository-qsdy395h.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/provider.ts
+var exports_provider = {};
+__export(exports_provider, {
+  ConfigProviderPlugin: () => exports_provider,
+  Plugin: () => Plugin10
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Money } from "@opencode/schema/money";
+import { Effect } from "effect";
+var Plugin10 = define({
+  id: "opencode.config.provider",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const loaded = yield* observe2(config, ctx.event, ctx.integration.reload().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* ctx.integration.transform((integrations) => {
+      for (const [id, provider] of configuredProviders(loaded.entries)) {
+        const integrationID = id;
+        if (!integrations.get(integrationID)) {
+          integrations.method.update({
+            integrationID,
+            method: { type: "key", label: "Manually enter API Key" }
+          });
+        }
+        integrations.update(integrationID, (integration) => {
+          integration.name = provider.name ?? integration.name;
+        });
+        if (provider.env !== undefined) {
+          integrations.method.update({
+            integrationID,
+            method: { type: "env", names: [...provider.env] }
+          });
+        }
+      }
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      const configuredDefault = latest2(loaded.entries, "model");
+      if (configuredDefault !== undefined)
+        catalog.model.default.set(configuredDefault.providerID, configuredDefault.model);
+      for (const [id, item] of configuredProviders(loaded.entries)) {
+        const providerID = id;
+        const current = catalog.provider.get(providerID);
+        const source = catalog.provider.get(item.canonical ?? current?.provider.canonical ?? providerID);
+        const changed = item.canonical !== undefined && item.canonical !== current?.provider.canonical;
+        catalog.provider.update(providerID, (provider) => {
+          if (changed && source && source.provider !== provider)
+            Object.assign(provider, structuredClone(source.provider), {
+              id: provider.id,
+              integrationID: provider.integrationID
+            });
+          provider.activation = "enabled";
+          if (item.canonical !== undefined)
+            provider.canonical = item.canonical;
+          if (item.name !== undefined)
+            provider.name = item.name;
+          if (item.package !== undefined)
+            provider.package = item.package;
+          if (item.compaction !== undefined)
+            provider.compaction = { ...item.compaction };
+          if (item.websocket !== undefined)
+            provider.websocket = item.websocket;
+          if (item.settings !== undefined)
+            provider.settings = mergeOverlay2(provider.settings, item.settings);
+          if (item.headers !== undefined)
+            provider.headers = mergeHeaders2(provider.headers, item.headers);
+          if (item.body !== undefined)
+            provider.body = mergeOverlay2(provider.body, item.body);
+        });
+        for (const [id, config] of Object.entries(item.models ?? {})) {
+          const base = source?.models.get(config.modelID ?? id) ?? source?.models.get(id);
+          const inherit = changed || !catalog.model.get(providerID, id);
+          catalog.model.update(providerID, id, (model) => {
+            if (inherit && base) {
+              Object.assign(model, structuredClone(base));
+              if (item.package !== undefined)
+                model.package = undefined;
+              if (item.settings?.baseURL !== undefined && model.settings)
+                delete model.settings.baseURL;
+            }
+            if (config.family !== undefined)
+              model.family = config.family;
+            if (config.name !== undefined)
+              model.name = config.name;
+            if (config.modelID !== undefined)
+              model.modelID = config.modelID;
+            if (config.compatibility !== undefined)
+              model.compatibility = { ...model.compatibility, ...config.compatibility };
+            if (config.package !== undefined)
+              model.package = config.package;
+            if (config.compaction !== undefined)
+              model.compaction = { ...config.compaction };
+            if (config.websocket !== undefined)
+              model.websocket = config.websocket;
+            if (config.settings !== undefined)
+              model.settings = mergeOverlay2(model.settings, config.settings);
+            if (config.headers !== undefined)
+              model.headers = mergeHeaders2(model.headers, config.headers);
+            if (config.body !== undefined)
+              model.body = mergeOverlay2(model.body, config.body);
+            if (config.capabilities !== undefined) {
+              model.capabilities = {
+                tools: config.capabilities.tools,
+                input: [...config.capabilities.input],
+                output: [...config.capabilities.output]
+              };
+            }
+            if (config.variants !== undefined) {
+              model.variants ??= [];
+              for (const variant of config.variants) {
+                let existing = model.variants.find((item) => item.id === variant.id);
+                if (!existing) {
+                  existing = { id: variant.id };
+                  model.variants.push(existing);
+                }
+                if (variant.settings !== undefined)
+                  existing.settings = mergeOverlay2(existing.settings, variant.settings);
+                if (variant.headers !== undefined)
+                  existing.headers = mergeHeaders2(existing.headers, variant.headers);
+                if (variant.body !== undefined)
+                  existing.body = mergeOverlay2(existing.body, variant.body);
+              }
+            }
+            if (config.cost !== undefined) {
+              model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
+                tier: cost.tier && { ...cost.tier },
+                input: cost.input,
+                output: cost.output,
+                cache: {
+                  read: cost.cache?.read ?? Money.USDPerMillionTokens.zero,
+                  write: cost.cache?.write ?? Money.USDPerMillionTokens.zero
+                }
+              }));
+            }
+            if (config.disabled !== undefined)
+              model.enabled = !config.disabled;
+            if (config.limit !== undefined)
+              model.limit = { ...model.limit, ...config.limit };
+          });
+        }
+      }
+    });
+  })
+});
+function configuredProviders(entries) {
+  return entries.filter((entry) => entry.type === "document").flatMap((file) => Object.entries(file.info.providers ?? {}));
+}
+
+export { Plugin10, exports_provider };

package/dist/chunks/repository-3smtnn6g.js

@@ -0,0 +1,45 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/mime.ts
+var exports_mime = {};
+__export(exports_mime, {
+  Mime: () => exports_mime,
+  detect: () => detect2
+});
+function detect2(bytes) {
+  if (startsWith(bytes, [137, 80, 78, 71, 13, 10, 26, 10]))
+    return "image/png";
+  if (startsWith(bytes, [255, 216, 255]))
+    return "image/jpeg";
+  if (startsWith(bytes, [71, 73, 70, 56]))
+    return "image/gif";
+  if (startsWith(bytes, [66, 77]))
+    return "image/bmp";
+  if (startsWith(bytes, [37, 80, 68, 70, 45]))
+    return "application/pdf";
+  if (startsWith(bytes, [82, 73, 70, 70]) && startsWith(bytes.subarray(8), [87, 69, 66, 80]))
+    return "image/webp";
+  if (startsWith(bytes.subarray(4), [102, 116, 121, 112]) && (startsWith(bytes.subarray(8), [97, 118, 105, 102]) || startsWith(bytes.subarray(8), [97, 118, 105, 115])))
+    return "image/avif";
+  return isText(bytes) ? "text/plain" : "application/octet-stream";
+}
+function startsWith(bytes, prefix) {
+  return prefix.every((value, index) => bytes[index] === value);
+}
+function isText(bytes) {
+  if (bytes.length === 0)
+    return true;
+  if (bytes.includes(0))
+    return false;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes, { stream: true });
+  } catch {
+    return false;
+  }
+  const controls = bytes.reduce((count, byte) => count + Number(byte < 9 || byte > 13 && byte < 32), 0);
+  return controls / bytes.length <= 0.3;
+}
+
+export { detect2, exports_mime };

package/dist/chunks/repository-3tamc9js.js

@@ -0,0 +1,89 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/command.ts
+var exports_command5 = {};
+__export(exports_command5, {
+  Command: () => exports_command5,
+  Event: () => Event16,
+  ExecutionError: () => ExecutionError2,
+  Info: () => Info27,
+  NotFoundError: () => NotFoundError9,
+  Service: () => Service69,
+  layer: () => layer22,
+  node: () => node73
+});
+import { Command } from "@opencode/schema/command";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Event as Event16 } from "@opencode/schema/command";
+var Info27 = Command.Info;
+
+class NotFoundError9 extends Schema.TaggedError()("Command.NotFoundError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class ExecutionError2 extends Schema.TaggedError()("Command.ExecutionError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service69 extends Context.Service()("@opencode/Command") {
+}
+var layer22 = Layer.effect(Service69, Effect.gen(function* () {
+  const bus = yield* Service78;
+  const state = create3({
+    name: "command",
+    initial: () => new Map,
+    editor: (editor) => ({
+      add: (definition) => editor.set(definition.name, definition)
+    }),
+    notify: () => bus.publish(Command.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const info = (definition) => Info27.make({
+    name: definition.name,
+    description: definition.description
+  });
+  return Service69.of({
+    reload: state.reload,
+    transform: state.transform,
+    get: Effect.fn("Command.get")((name) => Effect.sync(() => {
+      const definition = state.get().get(name);
+      return definition ? info(definition) : undefined;
+    })),
+    list: Effect.fn("Command.list")(() => Effect.sync(() => Array.from(state.get().values(), info))),
+    execute: Effect.fn("Command.execute")(function* (input) {
+      const definition = state.get().get(input.name);
+      if (!definition)
+        return yield* new NotFoundError9({ command: input.name, message: `Command not found: ${input.name}` });
+      return yield* definition.execute(input.invocation).pipe(Effect.tapError((error) => Effect.logError("command execution failed", { command: input.name, error })), Effect.mapError((error) => new ExecutionError2({ command: input.name, message: errorMessage(error) })));
+    })
+  });
+}));
+var node73 = makeLocationNode({
+  service: Service69,
+  layer: layer22,
+  deps: [node83]
+});
+function errorMessage(error) {
+  if (error instanceof Error)
+    return error.message;
+  if (typeof error === "string")
+    return error;
+  if (error && typeof error === "object" && "message" in error && typeof error.message === "string")
+    return error.message;
+  return "Command execution failed";
+}
+
+export { Info27, NotFoundError9, ExecutionError2, Service69, layer22, node73, exports_command5, Event16 };

package/dist/chunks/repository-3tvqynh2.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/database/v1-migration.ts
+var exports_v1_migration = {};
+__export(exports_v1_migration, {
+  V1Migration: () => V1Migration2
+});
+import * as V1Migration2 from "#v1-migration";
+
+export * from "#v1-migration";
+
+export { exports_v1_migration, V1Migration2 };

package/dist/chunks/repository-3v8g72cx.js

@@ -0,0 +1,28 @@
+// src/tool/http-body.ts
+import { Effect, Stream } from "effect";
+var collectBoundedResponseBody2 = (response, maximumBytes, tooLarge) => Effect.gen(function* () {
+  const contentLength = response.headers["content-length"];
+  const parsedSize = contentLength ? Number.parseInt(contentLength, 10) : undefined;
+  const declaredSize = parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined;
+  if (declaredSize !== undefined && declaredSize > maximumBytes)
+    return yield* Effect.fail(tooLarge());
+  let body = Buffer.allocUnsafe(Math.min(maximumBytes, declaredSize || 64 * 1024));
+  let size = 0;
+  yield* Stream.runForEach(response.stream, (chunk) => {
+    if (chunk.byteLength === 0)
+      return Effect.void;
+    if (size + chunk.byteLength > maximumBytes)
+      return Effect.fail(tooLarge());
+    if (size + chunk.byteLength > body.byteLength) {
+      const grown = Buffer.allocUnsafe(Math.min(maximumBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)));
+      body.copy(grown, 0, 0, size);
+      body = grown;
+    }
+    body.set(chunk, size);
+    size += chunk.byteLength;
+    return Effect.void;
+  });
+  return body.subarray(0, size);
+});
+
+export { collectBoundedResponseBody2 };

package/dist/chunks/repository-3w5fmr99.js

@@ -0,0 +1,214 @@
+// src/tool/runtime.ts
+import { Tool } from "@opencode/schema/tool";
+import { Cache, Effect, JsonSchema, Schema, SchemaIssue, SchemaRepresentation } from "effect";
+import { $ZodType, toJSONSchema } from "zod/v4/core";
+var formatEffectIssues = SchemaIssue.makeFormatterStandardSchemaV1();
+var jsonSchemas = Effect.runSync(Cache.make({
+  capacity: 100,
+  lookup: (schema) => Effect.try({
+    try: () => jsonSchema(schema),
+    catch: () => {
+      return;
+    }
+  }).pipe(Effect.orElseSucceed(() => {
+    return;
+  }))
+}));
+var definition2 = (tool) => ({
+  type: "tool",
+  name: effectiveName2(tool),
+  description: tool.description,
+  inputSchema: inputJsonSchema(tool.input),
+  ...tool.output === undefined ? {} : { outputSchema: outputJsonSchema(tool.output) }
+});
+var execute3 = (tool, input, context) => Effect.gen(function* () {
+  const decoded = yield* decodeInput(tool, input);
+  const result = yield* tool.execute(decoded, context).pipe(Effect.mapError((error) => error instanceof Tool.Error ? error : new Tool.Error({
+    message: error instanceof globalThis.Error ? error.message : String(error)
+  })));
+  if (tool.output === undefined) {
+    if ("output" in result)
+      return yield* Effect.die("Tool result declared output without an output schema");
+    return {
+      output: undefined,
+      content: normalizeContent2(result.content),
+      ...result.metadata === undefined ? {} : { metadata: result.metadata }
+    };
+  }
+  if (!("output" in result))
+    return yield* new Tool.Error({ message: "Tool did not return its declared output" });
+  const output = yield* encodeOutput(tool.output, result.output);
+  return {
+    output,
+    content: normalizeContent2(result.content, output),
+    ...result.metadata === undefined ? {} : { metadata: result.metadata }
+  };
+});
+var decodeInput = (tool, value) => Effect.gen(function* () {
+  const result = yield* validateInput(tool.input, value);
+  if (result.issues)
+    return yield* new Tool.Error({ message: formatInputIssues(effectiveName2(tool), result.issues, value) });
+  return result.value;
+});
+var validateInput = (schema, value) => {
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value);
+  return Effect.gen(function* () {
+    const codec = Schema.isSchema(schema) ? schema : yield* Cache.get(jsonSchemas, schema);
+    if (codec === undefined)
+      return { value };
+    return yield* Schema.decodeUnknownEffect(codec)(value, { errors: "all" }).pipe(Effect.match({
+      onFailure: (error) => formatEffectIssues(error.issue),
+      onSuccess: (value) => ({ value })
+    }));
+  });
+};
+var formatInputIssues = (tool, issues, value) => {
+  const details = issues.slice(0, 5).map((issue) => {
+    const path = issue.path?.reduce((path, segment) => {
+      const key = typeof segment === "object" ? segment.key : segment;
+      if (typeof key === "number")
+        return `${path}[${key}]`;
+      return path === "" ? String(key) : `${path}.${String(key)}`;
+    }, "") || "root";
+    return `- ${path}: ${issue.message}`;
+  });
+  if (issues.length > 5)
+    details.push(`- ...and ${issues.length - 5} more ${issues.length === 6 ? "issue" : "issues"}`);
+  return `Invalid arguments for tool "${tool}":
+${details.join(`
+`)}
+
+Arguments provided:
+${JSON.stringify(value, null, 2)}
+
+Update the arguments and call the tool again.`;
+};
+var jsonSchema = (schema) => {
+  const draft = typeof schema.$schema === "string" && schema.$schema.includes("draft-07") || "definitions" in schema ? JsonSchema.fromSchemaDraft07(schema) : JsonSchema.fromSchemaDraft2020_12(schema);
+  return Schema.make(SchemaRepresentation.fromJsonSchemaDocument(draft).ast);
+};
+var encodeOutput = (schema, value) => {
+  if (Schema.isSchema(schema))
+    return Schema.encodeEffect(schema)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned an invalid value for its output schema: ${error.message}` })));
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value).pipe(Effect.flatMap((result) => result.issues ? new Tool.Error({
+      message: `Tool returned an invalid value for its output schema: ${result.issues.map((issue) => issue.message).join(", ")}`
+    }) : Effect.succeed(result.value)));
+  return Schema.decodeUnknownEffect(Schema.Json)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned a non-JSON value for its output schema: ${error.message}` })));
+};
+var isStandardSchema = (schema) => typeof schema === "object" && schema !== null && ("~standard" in schema);
+var isStandardJSONSchema = (schema) => ("jsonSchema" in schema["~standard"]);
+var validateStandard = (schema, value) => Effect.gen(function* () {
+  const result = yield* Effect.try({ try: () => schema["~standard"].validate(value), catch: (error) => error });
+  return result instanceof Promise ? yield* Effect.tryPromise({ try: () => result, catch: (error) => error }) : result;
+}).pipe(Effect.match({
+  onFailure: (error) => ({ issues: [{ message: error instanceof Error ? error.message : String(error) }] }),
+  onSuccess: (result) => result
+}));
+var inputJsonSchema = (schema) => {
+  if (schema === undefined || schema === null)
+    return {};
+  if (isStandardSchema(schema))
+    return standardJsonSchema(schema, "input");
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var outputJsonSchema = (schema) => {
+  if (isStandardSchema(schema))
+    return standardJsonSchema(schema, "output");
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var standardJsonSchema = (schema, io) => {
+  if (isStandardJSONSchema(schema))
+    return schema["~standard"].jsonSchema[io]({ target: "draft-2020-12" });
+  if (schema instanceof $ZodType)
+    return toJSONSchema(schema, { target: "draft-2020-12", io });
+  throw new Error(`Schema vendor "${schema["~standard"].vendor}" does not support JSON Schema conversion`);
+};
+var toJsonSchema = (schema) => {
+  const document = Schema.toJsonSchemaDocument(schema);
+  const normalized = flattenAllOf(Object.keys(document.definitions).length === 0 ? document.schema : { ...document.schema, $defs: document.definitions });
+  return dropDefinitionsIfResolved(inlineLocalReferences(normalized));
+};
+var flattenAllOf = (value) => {
+  if (Array.isArray(value))
+    return value.map(flattenAllOf);
+  if (typeof value !== "object" || value === null)
+    return value;
+  const schema = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, flattenAllOf(item)]));
+  if (!Array.isArray(schema.allOf) || !schema.allOf.every(isRecord) || !canFlattenAllOf(schema.allOf, schema))
+    return schema;
+  const { allOf, ...rest } = schema;
+  return flattenAllOf({ ...Object.assign({}, ...allOf), ...rest });
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var canFlattenAllOf = (allOf, parent) => {
+  const keys = new Set(Object.keys(parent).filter((key) => key !== "allOf"));
+  return allOf.every((item) => Object.keys(item).every((key) => {
+    if (keys.has(key))
+      return false;
+    keys.add(key);
+    return true;
+  }));
+};
+var inlineLocalReferences = (value, definitions, seen = new Set) => {
+  if (Array.isArray(value))
+    return value.map((item) => inlineLocalReferences(item, definitions, seen));
+  if (!isRecord(value))
+    return value;
+  const localDefinitions = definitions ?? (isRecord(value.$defs) ? value.$defs : undefined);
+  if (typeof value.$ref === "string" && localDefinitions) {
+    const segment = value.$ref.match(/^#\/\$defs\/([^/]+)$/)?.[1];
+    const name = segment?.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (name && !seen.has(name)) {
+      const target = localDefinitions[name];
+      if (target) {
+        const { $ref: _, ...rest } = value;
+        const resolvedTarget = inlineLocalReferences(target, localDefinitions, new Set(seen).add(name));
+        const resolvedSiblings = inlineLocalReferences(rest, localDefinitions, seen);
+        if (!isRecord(resolvedTarget) || !isRecord(resolvedSiblings))
+          return resolvedTarget;
+        if (canMergeRecords(resolvedTarget, resolvedSiblings))
+          return { ...resolvedTarget, ...resolvedSiblings };
+        return { allOf: [resolvedTarget, resolvedSiblings] };
+      }
+    }
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, inlineLocalReferences(item, localDefinitions, seen)]));
+};
+var canMergeRecords = (left, right) => Object.keys(left).every((key) => !(key in right));
+var dropDefinitionsIfResolved = (value) => {
+  if (!isRecord(value) || hasLocalReference(value))
+    return value;
+  const { $defs: _, ...rest } = value;
+  return rest;
+};
+var hasLocalReference = (value) => {
+  if (Array.isArray(value))
+    return value.some(hasLocalReference);
+  if (!isRecord(value))
+    return false;
+  if (typeof value.$ref === "string" && value.$ref.startsWith("#/$defs/"))
+    return true;
+  return Object.values(value).some(hasLocalReference);
+};
+var normalizeContent2 = (value, output) => {
+  if (typeof value === "string")
+    return [{ type: "text", text: value }];
+  if (value !== undefined && value.length > 0)
+    return [...value];
+  return [{ type: "text", text: stringify(output) }];
+};
+var stringify = (value) => {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var normalizedName2 = (tool) => tool.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+var effectiveName2 = (tool) => tool.options?.namespace === undefined ? normalizedName2(tool) : `${tool.options.namespace.replaceAll(".", "_")}_${normalizedName2(tool)}`;
+
+export { definition2, execute3, normalizeContent2, normalizedName2, effectiveName2 };

package/dist/chunks/repository-3wcehsnq.js

@@ -0,0 +1,17 @@
+// src/github-copilot/responses/tool/web-search.ts
+import { z } from "zod/v4";
+var webSearchArgsSchema2 = z.object({
+  filters: z.object({
+    allowedDomains: z.array(z.string()).optional()
+  }).optional(),
+  searchContextSize: z.enum(["low", "medium", "high"]).optional(),
+  userLocation: z.object({
+    type: z.literal("approximate"),
+    country: z.string().optional(),
+    city: z.string().optional(),
+    region: z.string().optional(),
+    timezone: z.string().optional()
+  }).optional()
+});
+
+export { webSearchArgsSchema2 };