@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-dgf53888.js

@@ -0,0 +1,182 @@
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Service75,
+  node80
+} from "./aisdk-native-7zdm33ac.js";
+import {
+  parse4,
+  validateBranch3,
+  cachePath2,
+  same2
+} from "./aisdk-native-2402vzrj.js";
+import {
+  Service58,
+  node62
+} from "./aisdk-native-1xqm2dzv.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/repository-cache.ts
+var exports_repository_cache = {};
+__export(exports_repository_cache, {
+  CacheOperationError: () => CacheOperationError2,
+  CheckoutFailedError: () => CheckoutFailedError2,
+  CloneFailedError: () => CloneFailedError2,
+  FetchFailedError: () => FetchFailedError2,
+  InvalidBranchError: () => InvalidBranchError2,
+  LockFailedError: () => LockFailedError2,
+  RepositoryCache: () => exports_repository_cache,
+  ResetFailedError: () => ResetFailedError2,
+  Service: () => Service47,
+  isError: () => isError2,
+  node: () => node50,
+  validateBranch: () => validateBranch2
+});
+import path from "path";
+import { Clock, Context, Duration, Effect, Layer, Option, Schema } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { EffectFlock } from "@opencode/util/effect-flock";
+var Refresh = Schema.Struct({
+  attemptedAt: Schema.Number
+});
+var refreshInterval = Duration.toMillis(Duration.days(1));
+
+class InvalidBranchError2 extends Schema.TaggedError()("RepositoryCacheInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CloneFailedError2 extends Schema.TaggedError()("RepositoryCacheCloneFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class FetchFailedError2 extends Schema.TaggedError()("RepositoryCacheFetchFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CheckoutFailedError2 extends Schema.TaggedError()("RepositoryCacheCheckoutFailedError", {
+  repository: Schema.String,
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class ResetFailedError2 extends Schema.TaggedError()("RepositoryCacheResetFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class LockFailedError2 extends Schema.TaggedError()("RepositoryCacheLockFailedError", {
+  localPath: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CacheOperationError2 extends Schema.TaggedError()("RepositoryCacheOperationError", {
+  operation: Schema.String,
+  path: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service47 extends Context.Service()("@opencode/RepositoryCache") {
+}
+function isError2(error) {
+  return error instanceof InvalidBranchError2 || error instanceof CloneFailedError2 || error instanceof FetchFailedError2 || error instanceof CheckoutFailedError2 || error instanceof ResetFailedError2 || error instanceof LockFailedError2 || error instanceof CacheOperationError2;
+}
+var validateBranch2 = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
+  return yield* Effect.try({
+    try: () => validateBranch3(branch),
+    catch: (error) => new InvalidBranchError2({ branch, message: errorMessage(error) })
+  });
+});
+var layer = Layer.effect(Service47, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* Service75;
+  const flock = yield* EffectFlock.Service;
+  const global = yield* Global.Service;
+  const kv = yield* Service58;
+  return Service47.of({
+    ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
+      if (input.branch)
+        yield* validateBranch2(input.branch);
+      const repository = input.reference.label;
+      const localPath = cachePath2(global.repos, input.reference, input.branch);
+      const key = `repository-cache:${localPath}`;
+      const cloneTarget = parse4(input.reference.remote) ?? input.reference;
+      return yield* flock.withLock(Effect.gen(function* () {
+        yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath);
+        const existing = yield* git.repo.discover(AbsolutePath2.make(localPath));
+        const origin = existing ? yield* git.remote.get(existing) : undefined;
+        const originReference = origin ? parse4(origin) : undefined;
+        const worktree = existing ? yield* fs.resolve(localPath) : undefined;
+        const reuse = Boolean(existing && existing.worktree === worktree && originReference && same2(originReference, cloneTarget));
+        if (!reuse && (yield* fs.existsSafe(localPath))) {
+          yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath);
+        }
+        const now = yield* Clock.currentTimeMillis;
+        const previous = Option.getOrUndefined(Schema.decodeUnknownOption(Refresh)(yield* kv.get(key)));
+        const refresh = input.refresh === "daily" ? !previous || now - previous.attemptedAt >= refreshInterval : input.refresh;
+        const status = !reuse ? "cloned" : refresh ? "refreshed" : "cached";
+        if (status !== "cached") {
+          yield* kv.set(key, { attemptedAt: now });
+          if (status === "cloned") {
+            yield* git.repo.clone({
+              remote: input.reference.remote,
+              directory: AbsolutePath2.make(localPath),
+              branch: input.branch
+            }).pipe(Effect.mapError((error) => new CloneFailedError2({ repository, message: error.message })));
+          }
+          if (status === "refreshed") {
+            if (!existing)
+              return yield* new FetchFailedError2({ repository, message: "Repository is unavailable" });
+            yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
+            if (input.branch) {
+              yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
+            }
+            const branch = input.branch ?? (yield* git.history.defaultRemoteBranch(existing));
+            if (branch) {
+              yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError2({ repository, branch, message: error.message })));
+            }
+            const target = branch ?? (yield* git.history.branch(existing));
+            yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError2({ repository, message: error.message })));
+          }
+        }
+        const checkout = yield* git.repo.discover(AbsolutePath2.make(localPath));
+        return {
+          repository,
+          host: input.reference.host,
+          remote: input.reference.remote,
+          localPath,
+          status,
+          head: checkout ? yield* git.history.head(checkout) : undefined,
+          branch: checkout ? yield* git.history.branch(checkout) : undefined
+        };
+      }), key).pipe(Effect.mapError((error) => isError2(error) ? error : new LockFailedError2({ localPath, message: errorMessage(error) })));
+    })
+  });
+}));
+var node50 = makeGlobalNode({
+  service: Service47,
+  layer,
+  deps: [EffectFlock.node, FSUtil.node, node80, Global.node, node62]
+});
+function errorMessage(error) {
+  return error instanceof globalThis.Error ? error.message : String(error);
+}
+function cacheOperation(effect, operation, target) {
+  return effect.pipe(Effect.mapError((error) => new CacheOperationError2({ operation, path: target, message: errorMessage(error) })));
+}
+
+export { InvalidBranchError2, CloneFailedError2, FetchFailedError2, CheckoutFailedError2, ResetFailedError2, LockFailedError2, CacheOperationError2, Service47, isError2, validateBranch2, node50, exports_repository_cache };

package/dist/chunks/aisdk-native-dk95gbn1.js

@@ -0,0 +1,184 @@
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service42,
+  node45
+} from "./aisdk-native-81rrwt6s.js";
+import {
+  AbsolutePath2,
+  RelativePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Service74,
+  node79
+} from "./aisdk-native-ykq8g6tf.js";
+import {
+  Ref4
+} from "./aisdk-native-6fyvx278.js";
+import {
+  Service43,
+  node46
+} from "./aisdk-native-nhqh66qs.js";
+import {
+  SessionMessage2
+} from "./aisdk-native-gftt206x.js";
+import {
+  NotFoundError7
+} from "./aisdk-native-3x8gcmrs.js";
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  Service39
+} from "./aisdk-native-06x8he3q.js";
+import {
+  Service61,
+  node65
+} from "./aisdk-native-smbad60v.js";
+import {
+  Item2,
+  serialized2,
+  Service40,
+  node43,
+  moveIDs2
+} from "./aisdk-native-0fm13a2s.js";
+import {
+  Service38,
+  node42
+} from "./aisdk-native-ynnjbwyb.js";
+import {
+  node25
+} from "./aisdk-native-xrekznn2.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/move.ts
+var exports_move = {};
+__export(exports_move, {
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
+  DestinationNotFoundError: () => DestinationNotFoundError2,
+  DestinationUnavailableError: () => DestinationUnavailableError2,
+  Service: () => Service20,
+  SessionMove: () => exports_move,
+  node: () => node24
+});
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { Cause, Context, Effect, Layer, Schema } from "effect";
+import path from "path";
+class DestinationNotFoundError2 extends Schema.TaggedError()("Session.DestinationNotFoundError", { directory: AbsolutePath2 }) {
+}
+
+class DestinationNotDirectoryError2 extends Schema.TaggedError()("Session.DestinationNotDirectoryError", { directory: AbsolutePath2 }) {
+}
+
+class DestinationUnavailableError2 extends Schema.TaggedError()("Session.DestinationUnavailableError", { directory: AbsolutePath2 }) {
+}
+
+class Service20 extends Context.Service()("@opencode/SessionMove") {
+}
+var layer = Layer.effect(Service20, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const projects = yield* Service74;
+  const locations = yield* Service43;
+  const store = yield* Service61;
+  const execution = yield* Service38;
+  const instances = yield* Service42;
+  const admission = yield* Service40;
+  const database = yield* Service80;
+  const bus = yield* Service79;
+  const get = Effect.fn("SessionMove.get")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* new NotFoundError7({ sessionID });
+    return session;
+  });
+  const resolveDestination = Effect.fn("SessionMove.resolveDestination")(function* (session, input) {
+    const value = input.directory.trim();
+    const expanded = value === "~" ? global.home : value.startsWith("~/") ? path.join(global.home, value.slice(2)) : value;
+    const directory = AbsolutePath2.make(path.resolve(session.location.directory, expanded));
+    const info = yield* fs.stat(directory).pipe(Effect.orElseSucceed(() => {
+      return;
+    }));
+    if (!info)
+      return yield* new DestinationNotFoundError2({ directory });
+    if (info.type !== "Directory")
+      return yield* new DestinationNotDirectoryError2({ directory });
+    const project = yield* projects.resolve(directory);
+    const destination = {
+      location: Ref4.make({ directory, workspaceID: input.workspaceID }),
+      projectID: project.id,
+      subpath: RelativePath2.make(path.relative(project.directory, directory).replaceAll("\\", "/"))
+    };
+    yield* locations.contextEffect(destination.location).pipe(Effect.scoped, Effect.catchCause((cause) => {
+      if (Cause.hasInterruptsOnly(cause))
+        return Effect.failCause(cause);
+      return Effect.logWarning("session move destination unavailable", { directory, cause }).pipe(Effect.andThen(Effect.fail(new DestinationUnavailableError2({ directory }))));
+    }));
+    return destination;
+  });
+  const sourceUnavailable = Effect.fn("SessionMove.sourceUnavailable")(function* (session) {
+    if (yield* execution.isActive(session.id))
+      return false;
+    if (!(yield* fs.isDir(session.location.directory)))
+      return true;
+    return yield* Service39.pipe(instances.provide(session), Effect.as(false), Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.succeed(true)));
+  });
+  return Service20.of({
+    move: Effect.fn("SessionMove.move")(function* (input) {
+      const session = yield* get(input.sessionID);
+      const destination = yield* resolveDestination(session, input);
+      const unavailable = yield* sourceUnavailable(session);
+      const item = Item2.make({
+        type: "move",
+        payload: destination,
+        delivery: input.delivery ?? "steer"
+      });
+      yield* serialized2(input.sessionID, Effect.gen(function* () {
+        const latest = yield* get(input.sessionID);
+        if (unavailable && latest.location.directory === session.location.directory && latest.location.workspaceID === session.location.workspaceID && !(yield* execution.isActive(input.sessionID))) {
+          const cancellations = (yield* moveIDs2(database.db, input.sessionID)).map((item) => [SessionEvent2.InboxCancelled, { sessionID: input.sessionID, inboxID: item.id }]);
+          const moved = [SessionEvent2.Moved, { sessionID: input.sessionID, ...destination }];
+          const first = cancellations[0];
+          if (!first)
+            return yield* bus.publish(...moved).pipe(Effect.asVoid);
+          return yield* bus.publishAll([first, ...cancellations.slice(1), moved]);
+        }
+        yield* admission.admit({
+          id: SessionMessage2.ID.create(),
+          sessionID: input.sessionID,
+          item
+        }).pipe(Effect.orDie);
+      }));
+      yield* execution.wake(input.sessionID);
+    })
+  });
+}));
+var node24 = makeGlobalNode({
+  service: Service20,
+  layer,
+  deps: [
+    FSUtil.node,
+    Global.node,
+    node79,
+    node46,
+    node65,
+    node42,
+    node45,
+    node43,
+    node85,
+    node84,
+    node25
+  ]
+});
+
+export { DestinationNotFoundError2, DestinationNotDirectoryError2, DestinationUnavailableError2, Service20, node24, exports_move };

package/dist/chunks/aisdk-native-dp3vq9x5.js

@@ -0,0 +1,180 @@
+import {
+  NonNegativeInt2,
+  PositiveInt2,
+  RelativePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Service71,
+  node75
+} from "./aisdk-native-ms882c9x.js";
+import {
+  RipgrepBinary2
+} from "./aisdk-native-8d7r5vzw.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/ripgrep.ts
+var exports_ripgrep = {};
+__export(exports_ripgrep, {
+  Error: () => Error4,
+  InvalidPatternError: () => InvalidPatternError2,
+  Ripgrep: () => exports_ripgrep,
+  Service: () => Service70,
+  node: () => node74
+});
+import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { Entry, Match } from "@opencode/schema/filesystem";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { collectStream, waitForAbort } from "@opencode/util/process";
+var ERROR_BYTES = 8 * 1024;
+var MAX_SUBMATCHES = 100;
+var RawMatch = Schema.Struct({
+  type: Schema.Literal("match"),
+  data: Schema.Struct({
+    path: Schema.Struct({ text: Schema.String }),
+    lines: Schema.Struct({ text: Schema.String }),
+    line_number: PositiveInt2,
+    absolute_offset: NonNegativeInt2,
+    submatches: Schema.Array(Schema.Struct({
+      match: Schema.Struct({ text: Schema.String }),
+      start: NonNegativeInt2,
+      end: NonNegativeInt2
+    }))
+  })
+});
+var decodeJsonRecord = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+
+class Error4 extends Schema.TaggedError()("Ripgrep.Error", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class InvalidPatternError2 extends Schema.TaggedError()("Ripgrep.InvalidPatternError", {
+  pattern: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service70 extends Context.Service()("@opencode/Ripgrep") {
+}
+var failure = (message, cause) => new Error4({ message, cause });
+var normalizePath = (value) => value.replace(/^(?:\.[\\/])+/u, "").replace(/^[\\/]+/u, "").replaceAll("\\", "/");
+var isInvalidPattern = (stderr) => stderr.includes("regex parse error") || stderr.includes("error parsing regex");
+var layer = Layer.effect(Service70, Effect.gen(function* () {
+  const environment = yield* Service71;
+  const binary = yield* RipgrepBinary2.Service;
+  const run = (input) => {
+    const program = Effect.scoped(Effect.gen(function* () {
+      const handle = yield* environment.spawner.spawn(ChildProcess.make(yield* binary.filepath, input.args, { cwd: input.cwd, extendEnv: true, stdin: "ignore" }));
+      const stderrFiber = yield* collectStream(handle.stderr, ERROR_BYTES).pipe(Effect.map((output) => output.buffer.toString("utf8")), Effect.forkScoped);
+      let observed = 0;
+      const rows = yield* Stream.decodeText(handle.stdout).pipe(Stream.splitLines, Stream.filter((line) => line.length > 0), Stream.mapEffect(input.parse), Stream.filter((row) => row !== undefined), Stream.tap((row) => {
+        if (!input.onItem || observed++ >= input.limit)
+          return Effect.void;
+        return input.onItem(row);
+      }), Stream.take(input.limit + 1), Stream.runCollect);
+      const truncated = rows.length > input.limit;
+      if (truncated)
+        return rows.slice(0, input.limit);
+      const code = yield* handle.exitCode;
+      const stderr = yield* Fiber.join(stderrFiber);
+      if (input.pattern && code === 2 && isInvalidPattern(stderr)) {
+        return yield* new InvalidPatternError2({ pattern: input.pattern, message: stderr.trim() });
+      }
+      if (code !== 0 && code !== 1 && code !== 2) {
+        return yield* failure(stderr.trim() || `ripgrep failed with code ${code}`);
+      }
+      return code === 1 ? [] : rows;
+    }));
+    const abortable = input.signal ? program.pipe(Effect.raceFirst(waitForAbort(input.signal))) : program;
+    return abortable.pipe(Effect.mapError((cause) => cause instanceof Error4 || cause instanceof InvalidPatternError2 ? cause : failure("ripgrep execution failed", cause)));
+  };
+  return Service70.of({
+    glob: (input) => run({
+      cwd: input.cwd,
+      limit: input.limit,
+      signal: input.signal,
+      args: [
+        "--no-config",
+        "--files",
+        ...input.hidden ? ["--hidden"] : [],
+        ...input.follow ? ["--follow"] : [],
+        `--glob=${input.pattern}`,
+        ...input.hidden ? [] : ["--glob=!**/.*"],
+        "--glob=!**/.git/**",
+        "."
+      ],
+      parse: (line) => Effect.succeed(normalizePath(line))
+    }).pipe(Effect.map((result) => result.map((relative) => Entry.make({
+      path: RelativePath2.make(relative),
+      type: "file"
+    }))), Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
+    find: (input) => run({
+      cwd: input.cwd,
+      limit: input.limit,
+      signal: input.signal,
+      args: [
+        "--no-config",
+        "--files",
+        ...input.hidden ? ["--hidden"] : [],
+        ...input.follow ? ["--follow"] : [],
+        ...input.pattern === "*" ? [] : [`--glob=${input.pattern}`],
+        ...(input.exclude ?? []).map((pattern) => `--glob=!${pattern}`),
+        "--glob=!**/.git/**",
+        "."
+      ],
+      parse: (line) => {
+        const relative = normalizePath(line);
+        return Effect.succeed(Entry.make({
+          path: RelativePath2.make(relative),
+          type: "file"
+        }));
+      },
+      onItem: input.onEntry
+    }).pipe(Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
+    grep: (input) => run({
+      ...input,
+      args: [
+        "--no-config",
+        "--json",
+        "--hidden",
+        "--no-messages",
+        ...input.literal ? ["--fixed-strings"] : [],
+        ...input.caseSensitive === false ? ["--ignore-case"] : [],
+        ...input.include ? [`--glob=${input.include}`] : [],
+        "--glob=!**/.git/**",
+        "--",
+        input.pattern,
+        input.file ?? "."
+      ],
+      parse: (line) => decodeJsonRecord(line).pipe(Effect.mapError((cause) => failure("Invalid ripgrep JSON output", cause)), Effect.flatMap((json) => {
+        if (!json || typeof json !== "object" || !("type" in json) || json.type !== "match")
+          return Effect.undefined;
+        return Schema.decodeUnknownEffect(RawMatch)(json).pipe(Effect.map((match) => ({
+          ...match.data,
+          path: { text: normalizePath(match.data.path.text) },
+          submatches: match.data.submatches.slice(0, MAX_SUBMATCHES)
+        })), Effect.mapError((cause) => failure("Invalid ripgrep match output", cause)));
+      }))
+    }).pipe(Effect.map((result) => result.map((match) => Match.make({
+      entry: Entry.make({
+        path: RelativePath2.make(match.path.text),
+        type: "file"
+      }),
+      line: match.line_number,
+      offset: match.absolute_offset,
+      text: match.lines.text.length > 2000 ? match.lines.text.slice(0, 2000) + "..." : match.lines.text,
+      submatches: match.submatches.map((submatch) => ({
+        text: submatch.match.text,
+        start: submatch.start,
+        end: submatch.end
+      }))
+    }))))
+  });
+}));
+var node74 = makeLocationNode({ service: Service70, layer, deps: [node75, RipgrepBinary2.node] });
+
+export { Error4, InvalidPatternError2, Service70, node74, exports_ripgrep };

package/dist/chunks/aisdk-native-e5kj55wp.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260507164347_add_workspace_time.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260507164347_add_workspace_time",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`time_used\` integer NOT NULL DEFAULT 0;`);
+    });
+  }
+};
+var _20260507164347_add_workspace_time_default = migration;
+
+export { _20260507164347_add_workspace_time_default };

package/dist/chunks/aisdk-native-e6hmchc5.js

@@ -0,0 +1,98 @@
+import {
+  PositiveInt2
+} from "./aisdk-native-922hggd3.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/v1/config/provider.ts
+var exports_provider2 = {};
+__export(exports_provider2, {
+  ConfigProviderV1: () => exports_provider2,
+  Info: () => Info13,
+  Model: () => Model2,
+  ModelStatus: () => ModelStatus2
+});
+import { Schema } from "effect";
+var ModelStatus2 = Schema.Literals(["alpha", "beta", "deprecated", "active"]);
+var Model2 = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  family: Schema.optional(Schema.String),
+  release_date: Schema.optional(Schema.String),
+  attachment: Schema.optional(Schema.Boolean),
+  reasoning: Schema.optional(Schema.Boolean),
+  temperature: Schema.optional(Schema.Boolean),
+  tool_call: Schema.optional(Schema.Boolean),
+  interleaved: Schema.optional(Schema.Union([
+    Schema.Boolean,
+    Schema.String,
+    Schema.Struct({
+      field: Schema.String
+    })
+  ])),
+  cost: Schema.optional(Schema.Struct({
+    input: Schema.Finite,
+    output: Schema.Finite,
+    cache_read: Schema.optional(Schema.Finite),
+    cache_write: Schema.optional(Schema.Finite),
+    context_over_200k: Schema.optional(Schema.Struct({
+      input: Schema.Finite,
+      output: Schema.Finite,
+      cache_read: Schema.optional(Schema.Finite),
+      cache_write: Schema.optional(Schema.Finite)
+    }))
+  })),
+  limit: Schema.optional(Schema.Struct({
+    context: Schema.Finite,
+    input: Schema.optional(Schema.Finite),
+    output: Schema.Finite
+  })),
+  modalities: Schema.optional(Schema.Struct({
+    input: Schema.optional(Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"])))),
+    output: Schema.optional(Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"]))))
+  })),
+  experimental: Schema.optional(Schema.Boolean),
+  status: Schema.optional(ModelStatus2),
+  provider: Schema.optional(Schema.Struct({ npm: Schema.optional(Schema.String), api: Schema.optional(Schema.String) })),
+  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  variants: Schema.optional(Schema.Record(Schema.String, Schema.StructWithRest(Schema.Struct({
+    disabled: Schema.optional(Schema.Boolean).annotate({ description: "Disable this variant for the model" })
+  }), [Schema.Record(Schema.String, Schema.Any)])).annotate({ description: "Variant-specific configuration" }))
+});
+var Info13 = Schema.Struct({
+  api: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  env: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  id: Schema.optional(Schema.String),
+  npm: Schema.optional(Schema.String),
+  whitelist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  blacklist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  options: Schema.optional(Schema.StructWithRest(Schema.Struct({
+    apiKey: Schema.optional(Schema.String),
+    baseURL: Schema.optional(Schema.String),
+    enterpriseUrl: Schema.optional(Schema.String).annotate({
+      description: "GitHub Enterprise URL for copilot authentication"
+    }),
+    setCacheKey: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable promptCacheKey for this provider (default false)"
+    }),
+    timeout: Schema.optional(Schema.Union([PositiveInt2, Schema.Literal(false)]).annotate({
+      description: "Timeout in milliseconds for full requests to this provider. Set to false to disable timeout."
+    })).annotate({
+      description: "Timeout in milliseconds for full requests to this provider. Set to false to disable timeout."
+    }),
+    headerTimeout: Schema.optional(Schema.Union([PositiveInt2, Schema.Literal(false)]).annotate({
+      description: "Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout."
+    })).annotate({
+      description: "Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout."
+    }),
+    chunkTimeout: Schema.optional(PositiveInt2).annotate({
+      description: "Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted."
+    })
+  }), [Schema.Record(Schema.String, Schema.Any)])),
+  models: Schema.optional(Schema.Record(Schema.String, Model2))
+}).annotate({ identifier: "ProviderConfig" });
+
+export { ModelStatus2, Model2, Info13, exports_provider2 };