@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-hdh8wb4y.js

@@ -0,0 +1,63 @@
+import {
+  exports_instructions
+} from "./ripgrep-8k8ks5a6.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/instructions/builtins.ts
+var exports_builtins = {};
+__export(exports_builtins, {
+  node: () => node,
+  Service: () => Service,
+  InstructionBuiltIns: () => exports_builtins
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, DateTime, Effect, Layer, Schema } from "effect";
+import { Global } from "@opencode-ai/util/global";
+class Service extends Context.Service()("@opencode/InstructionBuiltIns") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const location = yield* exports_location.Service;
+  return Service.of({
+    load: (sessionID) => Effect.succeed(exports_instructions.combine([
+      exports_instructions.make({
+        key: exports_instructions.Key.make("core/environment"),
+        codec: Schema.toCodecJson(Schema.String),
+        read: Effect.sync(() => [
+          "<env>",
+          `  Current conversation session ID: ${sessionID}`,
+          `  Working directory: ${location.directory}`,
+          `  Workspace root folder: ${location.project.directory}`,
+          `  Is directory a git repo: ${location.vcs?.type === "git" ? "yes" : "no"}`,
+          `  Platform: ${process.platform}`,
+          `  Use ${global.tmp} for temporary work outside the workspace; it already exists and is pre-approved for external directory access.`,
+          "</env>"
+        ].join(`
+`)),
+        render: {
+          initial: (environment) => ["Here is some useful information about the environment you are running in:", environment].join(`
+`),
+          changed: (_previous, environment) => ["The environment you are running in is now:", environment].join(`
+`)
+        }
+      }),
+      exports_instructions.make({
+        key: exports_instructions.Key.make("core/date"),
+        codec: Schema.toCodecJson(Schema.String),
+        read: DateTime.nowAsDate.pipe(Effect.map((date) => date.toDateString())),
+        render: {
+          initial: (date) => `Today's date: ${date}`,
+          changed: (_previous, date) => `Today's date is now: ${date}`
+        }
+      })
+    ]))
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [Global.node, exports_location.node] });
+
+export { Service, node, exports_builtins };

package/dist/chunks/ripgrep-hg7fqcsf.js

@@ -0,0 +1,121 @@
+import {
+  configuredSettings
+} from "./ripgrep-th2whxwy.js";
+import {
+  iife
+} from "./ripgrep-ehj9csmv.js";
+import {
+  exports_app
+} from "./ripgrep-50jxp3hw.js";
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/provider/cloudflare-ai-gateway.ts
+import os from "os";
+import { Effect, Option, Schema } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Form } from "@opencode-ai/schema/form";
+var providerID = exports_provider.ID.make("cloudflare-ai-gateway");
+var CloudflareAIGatewayPlugin = define({
+  id: "opencode.provider.cloudflare-ai-gateway",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings(providerID);
+    const form = iife(() => {
+      if (typeof configured?.baseURL === "string")
+        return;
+      const accountId = process.env.CLOUDFLARE_ACCOUNT_ID || stringOption(configured ?? {}, "accountId");
+      const gatewayId = process.env.CLOUDFLARE_GATEWAY_ID || stringOption(configured ?? {}, "gatewayId") || stringOption(configured ?? {}, "gateway");
+      if (accountId && gatewayId)
+        return;
+      const accountIdForm = Form.StringField.make({
+        type: "string",
+        key: "accountId",
+        title: "Enter your Cloudflare Account ID",
+        placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+        required: true
+      });
+      const gatewayIdForm = Form.StringField.make({
+        type: "string",
+        key: "gatewayId",
+        title: "Enter your Cloudflare AI Gateway ID",
+        placeholder: "e.g. my-gateway",
+        required: true
+      });
+      if (accountId)
+        return Form.Fields.make([gatewayIdForm]);
+      if (gatewayId)
+        return Form.Fields.make([accountIdForm]);
+      return Form.Fields.make([accountIdForm, gatewayIdForm]);
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "Gateway API token",
+          form
+        }
+      });
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "ai-gateway-provider")
+        return;
+      if (evt.options.baseURL)
+        return;
+      const config = gatewayConfig(evt.options);
+      if (!config)
+        return;
+      const metadata = gatewayMetadata(evt.options);
+      const { createAiGateway } = yield* Effect.promise(() => import("ai-gateway-provider")).pipe(Effect.orDie);
+      const { createUnified } = yield* Effect.promise(() => import("ai-gateway-provider/providers/unified")).pipe(Effect.orDie);
+      const gateway = createAiGateway({
+        accountId: config.accountId,
+        gateway: config.gatewayId,
+        apiKey: config.apiKey,
+        options: gatewayOptions(evt.options, metadata, ctx.app)
+      });
+      const unified = createUnified({ apiKey: config.apiKey });
+      evt.sdk = {
+        languageModel(modelID) {
+          return gateway(unified(modelID));
+        }
+      };
+    }));
+  })
+});
+var decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString);
+function gatewayConfig(options) {
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId");
+  const gatewayId = process.env.CLOUDFLARE_GATEWAY_ID ?? stringOption(options, "gatewayId") ?? stringOption(options, "gateway");
+  const apiKey = process.env.CLOUDFLARE_API_TOKEN ?? process.env.CF_AIG_TOKEN ?? stringOption(options, "apiKey");
+  if (!accountId || !gatewayId || !apiKey)
+    return;
+  return { accountId, gatewayId, apiKey };
+}
+function gatewayMetadata(options) {
+  if (options.metadata !== undefined)
+    return options.metadata;
+  const raw = options.headers?.["cf-aig-metadata"];
+  return raw ? Option.getOrUndefined(decodeJson(raw)) : undefined;
+}
+function gatewayOptions(options, metadata, app) {
+  return {
+    metadata,
+    cacheTtl: options.cacheTtl,
+    cacheKey: options.cacheKey,
+    skipCache: options.skipCache,
+    collectLog: options.collectLog,
+    headers: {
+      "User-Agent": `${exports_app.useragent(app)} cloudflare-ai-gateway (${os.platform()} ${os.release()}; ${os.arch()})`
+    }
+  };
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareAIGatewayPlugin };

package/dist/chunks/ripgrep-hkcvyz4t.js

@@ -0,0 +1,142 @@
+import {
+  imageGenerationArgsSchema
+} from "./ripgrep-4b2tz2m9.js";
+import {
+  codeInterpreterArgsSchema
+} from "./ripgrep-5a5ch9ts.js";
+import {
+  fileSearchArgsSchema
+} from "./ripgrep-wj4sxzqa.js";
+import {
+  webSearchPreviewArgsSchema
+} from "./ripgrep-7n9qwqk4.js";
+import {
+  webSearchArgsSchema
+} from "./ripgrep-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/ripgrep-hkp4zrd4.js

@@ -0,0 +1,124 @@
+import {
+  exports_catalog
+} from "./ripgrep-57tzwnz4.js";
+import {
+  exports_instructions
+} from "./ripgrep-8k8ks5a6.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/codemode/instructions.ts
+var exports_instructions2 = {};
+__export(exports_instructions2, {
+  update: () => update,
+  render: () => render,
+  make: () => make,
+  CodeModeInstructions: () => exports_instructions2
+});
+import { searchSignature, toolExpression } from "@opencode-ai/codemode";
+import { Effect, Schema } from "effect";
+var prompt = (hasMoreTools) => `The Code Mode tool catalog below is ${hasMoreTools ? "partial" : "complete"}.
+
+${hasMoreTools ? "The Code Mode catalog and `search` results are" : "This catalog is"} the complete set of tools available within Code Mode. Tools presented elsewhere are not available in this runtime.${hasMoreTools ? `
+
+## Search
+
+Use \`search\` to discover exact paths and signatures for additional tools:
+
+- ${searchSignature}` : ""}
+
+## Available tools`;
+function render(catalog) {
+  if (catalog.total === 0)
+    return "No Code Mode tools are currently available. Later Code Mode catalog updates may add or remove tools. Do not call `execute` unless there is at least one available Code Mode tool.";
+  const tools = catalog.namespaces.flatMap((namespace) => {
+    const count = namespace.count === 1 ? "1 tool" : `${namespace.count} tools`;
+    const label = namespace.entries.length === namespace.count ? count : namespace.entries.length === 0 ? `${count}, none shown` : `${count}, ${namespace.entries.length} shown`;
+    return [`- ${namespace.name} (${label})`, ...namespace.entries.map((entry) => entry.line)];
+  });
+  return `${prompt(catalog.shown < catalog.total)}
+
+${tools.join(`
+`)}`;
+}
+function update(previous, current) {
+  const replacement = `The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.
+
+${render(current)}`;
+  if (current.total === 0)
+    return replacement;
+  const previousComplete = previous.shown === previous.total;
+  const currentComplete = current.shown === current.total;
+  if (previousComplete !== currentComplete)
+    return replacement;
+  const diff = exports_instructions.diffByKey(previous.namespaces.flatMap((namespace) => namespace.entries), current.namespaces.flatMap((namespace) => namespace.entries), (entry) => entry.path, (before, after) => before.line !== after.line);
+  const entriesChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0;
+  if (!currentComplete) {
+    if (entriesChanged)
+      return replacement;
+    const namespaces = exports_instructions.diffByKey(previous.namespaces, current.namespaces, (namespace) => namespace.name, (before, after) => before.count !== after.count);
+    const changed = namespaces.added.length > 0 || namespaces.removed.length > 0 || namespaces.changed.length > 0;
+    if (!changed)
+      return replacement;
+    const parts2 = ["The Code Mode tool catalog has changed."];
+    if (namespaces.added.length > 0) {
+      parts2.push(`New tool namespaces are available: ${namespaces.added.map((namespace) => `\`${namespace.name}\` (${namespace.count} tools)`).join(", ")}.`);
+    }
+    if (namespaces.changed.length > 0) {
+      parts2.push(`The following namespace inventories changed; search them again before relying on previous results: ${namespaces.changed.map((change) => `\`${change.current.name}\` now has ${change.current.count} tools`).join(", ")}.`);
+    }
+    if (namespaces.removed.length > 0) {
+      parts2.push(`The following tool namespaces are no longer available and must not be used: ${namespaces.removed.map((namespace) => `\`${namespace.name}\``).join(", ")}.`);
+    }
+    const delta2 = parts2.join(`
+
+`);
+    if (delta2.length < replacement.length)
+      return delta2;
+    return replacement;
+  }
+  if (!entriesChanged)
+    return replacement;
+  const parts = ["The Code Mode tool catalog has changed."];
+  if (diff.added.length > 0) {
+    parts.push([
+      "New tools are available in addition to those previously listed:",
+      ...diff.added.map((entry) => entry.line)
+    ].join(`
+`));
+  }
+  if (diff.changed.length > 0) {
+    parts.push([
+      "Changed tool listings supersede the previously listed ones:",
+      ...diff.changed.map((change) => change.current.line)
+    ].join(`
+`));
+  }
+  if (diff.removed.length > 0) {
+    parts.push(`The following tools are no longer available and must not be called: ${diff.removed.map((entry) => toolExpression(entry.path)).join(", ")}.`);
+  }
+  const delta = parts.join(`
+
+`);
+  if (delta.length < replacement.length)
+    return delta;
+  return replacement;
+}
+var key = exports_instructions.Key.make("core/codemode");
+var codec = Schema.toCodecJson(exports_catalog.Summary);
+var make = (entries) => {
+  const catalog = entries === undefined ? exports_instructions.removed : exports_catalog.summarize(entries);
+  return exports_instructions.make({
+    key,
+    codec,
+    read: Effect.succeed(catalog),
+    render: {
+      initial: render,
+      changed: update,
+      removed: () => "Code Mode tools are no longer available. Do not use any previously listed Code Mode tools."
+    }
+  });
+};
+
+export { render, update, make, exports_instructions2 as exports_instructions };

package/dist/chunks/ripgrep-hsyk7kfz.js

@@ -0,0 +1,56 @@
+import {
+  buildSQLiteMigrationBackfillStatements,
+  prepareSQLiteMigrationBackfill
+} from "./ripgrep-4zg0gww9.js";
+import {
+  GET_VERSION_FOR,
+  MIGRATIONS_TABLE_VERSIONS
+} from "./ripgrep-f84sxdqn.js";
+
+// src/database/drizzle/up-migrations/effect-sqlite.ts
+import * as Effect from "effect/Effect";
+import { EffectDrizzleError } from "drizzle-orm/effect-core/errors";
+import { sql } from "drizzle-orm/sql/sql";
+var migrationUpgradeError = (cause) => new EffectDrizzleError({
+  message: typeof cause === "object" && cause !== null && "message" in cause && typeof cause.message === "string" ? cause.message : String(cause),
+  cause
+});
+var upgradeIfNeeded = Effect.fn("upgradeIfNeeded")(function* (migrationsTable, session, localMigrations) {
+  const tableExists = yield* session.all(sql`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ${migrationsTable}`);
+  if (tableExists.length === 0) {
+    return { newDb: true };
+  }
+  const rows = yield* session.all(sql`SELECT name as column_name FROM pragma_table_info(${migrationsTable})`);
+  const version = GET_VERSION_FOR.sqlite(rows.map((r) => r.column_name));
+  for (let v = version;v < MIGRATIONS_TABLE_VERSIONS.sqlite; v++) {
+    const upgradeFn = upgradeFunctions[v];
+    if (!upgradeFn) {
+      return yield* new EffectDrizzleError({
+        message: `No upgrade path from migration table version ${v} to ${v + 1}`,
+        cause: { version: v }
+      });
+    }
+    yield* upgradeFn(migrationsTable, session, localMigrations);
+  }
+  return { newDb: false };
+});
+var upgradeFunctions = {
+  0: upgradeFromV0
+};
+function upgradeFromV0(migrationsTable, session, localMigrations) {
+  return Effect.gen(function* () {
+    const table = sql`${sql.identifier(migrationsTable)}`;
+    const dbRows = yield* session.all(sql`SELECT id, hash, created_at FROM ${table} ORDER BY id ASC`);
+    const statements = yield* Effect.try({
+      try: () => buildSQLiteMigrationBackfillStatements(migrationsTable, prepareSQLiteMigrationBackfill(dbRows, localMigrations)),
+      catch: migrationUpgradeError
+    });
+    yield* session.transaction((tx) => Effect.gen(function* () {
+      for (const statement of statements) {
+        yield* tx.run(statement);
+      }
+    }));
+  });
+}
+
+export { upgradeIfNeeded };

package/dist/chunks/ripgrep-hzeg9cfr.js

@@ -0,0 +1,49 @@
+// src/util/error.ts
+import { Schema } from "effect";
+
+class NamedError extends Error {
+  static hasName(error, name) {
+    return typeof error === "object" && error !== null && "name" in error && error.name === name;
+  }
+  static create(name, data) {
+    return NamedError.createSchemaClass(name, Schema.isSchema(data) ? data : Schema.Struct(data));
+  }
+  static createSchemaClass(name, data) {
+    const schema = Schema.Struct({
+      name: Schema.Literal(name),
+      data
+    }).annotate({ identifier: name });
+    const result = class extends NamedError {
+      data;
+      static Schema = schema;
+      static EffectSchema = schema;
+      static tag = name;
+      name = name;
+      constructor(data2, options) {
+        super(name, options);
+        this.data = data2;
+        this.name = name;
+      }
+      static isInstance(input) {
+        return NamedError.hasName(input, name);
+      }
+      schema() {
+        return schema;
+      }
+      toObject() {
+        return {
+          name,
+          data: this.data
+        };
+      }
+    };
+    Object.defineProperty(result, "name", { value: name });
+    return result;
+  }
+  static Unknown = NamedError.create("UnknownError", {
+    message: Schema.String,
+    ref: Schema.optional(Schema.String)
+  });
+}
+
+export { NamedError };

package/dist/chunks/ripgrep-j07kk359.js

@@ -0,0 +1,21 @@
+// src/schema.ts
+import { Schema } from "effect";
+import {
+  AbsolutePath,
+  DateTimeUtcFromMillis,
+  NonNegativeInt,
+  optional,
+  PositiveInt,
+  RelativePath,
+  statics
+} from "@opencode-ai/schema/schema";
+function Newtype() {
+  return (tag, schema) => {
+    class Base {
+    }
+    Object.setPrototypeOf(Base, schema.pipe(Schema.brand(tag)));
+    return Base;
+  };
+}
+
+export { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, optional, PositiveInt, RelativePath, statics, Newtype };

package/dist/chunks/ripgrep-j1a5h53y.js

@@ -0,0 +1,30 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/effect/app-node-platform.ts
+var exports_app_node_platform = {};
+__export(exports_app_node_platform, {
+  webSocketConstructor: () => webSocketConstructor,
+  requestExecutor: () => requestExecutor,
+  llmClient: () => llmClient,
+  LayerNodePlatform: () => exports_app_node_platform
+});
+import { LLMClient, RequestExecutor } from "@opencode-ai/ai/route";
+import { NodeSocket } from "@effect/platform-node";
+import { Socket } from "effect/unstable/socket";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+var requestExecutor = makeGlobalNode({
+  service: RequestExecutor.Service,
+  layer: RequestExecutor.layer,
+  deps: [httpClient]
+});
+var llmClient = makeGlobalNode({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor] });
+var webSocketConstructor = makeGlobalNode({
+  service: Socket.WebSocketConstructor,
+  layer: NodeSocket.layerWebSocketConstructorWS,
+  deps: []
+});
+
+export { requestExecutor, llmClient, webSocketConstructor, exports_app_node_platform };