@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-bsphrc86.js

@@ -0,0 +1,113 @@
+import {
+  toLLMMessages
+} from "./ripgrep-6jtjggv5.js";
+import {
+  exports_context
+} from "./ripgrep-s2kxjwsf.js";
+import {
+  exports_prompt_cache_key
+} from "./ripgrep-52jzav25.js";
+import {
+  exports_model_headers
+} from "./ripgrep-1xksxgzs.js";
+import {
+  exports_system_prompt
+} from "./ripgrep-v80zsxnb.js";
+import {
+  exports_generate
+} from "./ripgrep-xgv25zxy.js";
+import {
+  exports_model
+} from "./ripgrep-h90v6ecj.js";
+import {
+  llmClient
+} from "./ripgrep-j1a5h53y.js";
+import {
+  exports_hooks
+} from "./ripgrep-0dwyqmzq.js";
+import {
+  exports_app
+} from "./ripgrep-50jxp3hw.js";
+import {
+  exports_history
+} from "./ripgrep-yndnp7z4.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/generate-node.ts
+var exports_generate_node = {};
+__export(exports_generate_node, {
+  node: () => node,
+  layer: () => layer,
+  SessionGenerateNode: () => exports_generate_node
+});
+import { LLM, LLMClient, Message, SystemPart } from "@opencode-ai/ai";
+import { Effect, Layer } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var layer = Layer.effect(exports_generate.Service, Effect.gen(function* () {
+  const context = yield* exports_context.Service;
+  const database = yield* exports_database.Service;
+  const hooks = yield* exports_hooks.Service;
+  const llm = yield* LLMClient.Service;
+  const models = yield* exports_model.Service;
+  const app = yield* exports_app.Metadata;
+  return exports_generate.Service.of({
+    generate: Effect.fn("SessionGenerate.generate")(function* (input) {
+      const selection = yield* context.select(input.sessionID);
+      const model = yield* models.resolve(selection.session);
+      const history = yield* exports_history.preview(database.db, selection.session.id, selection.instructions);
+      const providerMetadataKey = model.model.route.providerMetadataKey ?? model.model.provider;
+      const tools = selection.tools;
+      const toolDefinitions = tools.definitions;
+      const toolsByName = new Map(toolDefinitions.map((tool) => [tool.name, tool]));
+      const contextEvent = yield* hooks.trigger("session", "context", {
+        sessionID: selection.session.id,
+        agent: selection.agent.id,
+        model: model.ref,
+        system: [
+          selection.agent.info.system ? selection.agent.info.system : exports_system_prompt.make(toolDefinitions.map((tool) => tool.name)),
+          history.initial
+        ].filter((part) => part.length > 0).map(SystemPart.make),
+        messages: [
+          ...toLLMMessages(history.messages, model.ref, providerMetadataKey),
+          ...history.instructionUpdate ? [Message.system(history.instructionUpdate)] : [],
+          Message.user(input.prompt)
+        ],
+        tools: Object.fromEntries(toolDefinitions.map((tool) => [
+          tool.name,
+          { description: tool.description, input: { ...tool.inputSchema } }
+        ]))
+      });
+      const hookedTools = Object.entries(contextEvent.tools).flatMap(([name, tool]) => {
+        const registered = toolsByName.get(name);
+        return registered ? [Object.assign({}, registered, { description: tool.description, inputSchema: tool.input })] : [];
+      });
+      yield* Effect.logInfo("sending session generation request", {
+        sessionID: selection.session.id,
+        providerID: model.ref.providerID,
+        modelID: model.ref.id
+      });
+      const response = yield* llm.generate(LLM.request({
+        model: model.model,
+        http: { headers: exports_model_headers.make(selection.session, app) },
+        promptCacheKey: exports_prompt_cache_key.make(selection.session.id),
+        system: contextEvent.system,
+        messages: contextEvent.messages,
+        tools: hookedTools
+      }));
+      yield* Effect.logInfo("session generation usage diagnostic", { usage: response.usage });
+      return response.text;
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: exports_generate.Service,
+  layer,
+  deps: [exports_context.node, exports_database.node, exports_hooks.node, exports_model.node, exports_app.node, llmClient]
+});
+
+export { layer, node, exports_generate_node };

package/dist/chunks/ripgrep-bw3yp035.js

@@ -0,0 +1,70 @@
+import {
+  exports_markdown
+} from "./ripgrep-7wcmqxrc.js";
+import {
+  exports_skill
+} from "./ripgrep-p5bd5gkc.js";
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/plugin/skill-file.ts
+var exports_skill_file = {};
+__export(exports_skill_file, {
+  parse: () => parse,
+  SkillFile: () => exports_skill_file
+});
+import path from "path";
+import { Result, Schema, SchemaParser } from "effect";
+var Frontmatter = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  slash: Schema.Boolean.pipe(Schema.optional),
+  metadata: Schema.Unknown.pipe(Schema.optional)
+});
+var decodeFrontmatter = SchemaParser.decodeUnknownResult(Frontmatter);
+var metadataBoolean = (metadata, key) => {
+  if (metadata === undefined || metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return;
+  }
+  const value = Reflect.get(metadata, key);
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value !== "string")
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  return;
+};
+function parse(directory, filepath, content) {
+  const markdown = exports_markdown.parseOption(content);
+  if (!markdown)
+    return { _tag: "Skipped", reason: "markdown" };
+  const decoded = decodeFrontmatter(markdown.data);
+  if (Result.isFailure(decoded))
+    return { _tag: "Skipped", reason: "frontmatter", issue: decoded.failure };
+  const frontmatter = decoded.success;
+  const id = path.dirname(filepath) === directory ? path.basename(filepath, ".md") : path.basename(path.dirname(filepath));
+  const slash = metadataBoolean(frontmatter.metadata, "opencode/slash") ?? frontmatter.slash;
+  const autoinvoke = metadataBoolean(frontmatter.metadata, "opencode/autoinvoke");
+  return {
+    _tag: "Parsed",
+    skill: {
+      id: exports_skill.ID.make(id),
+      name: exports_skill.Name.make(frontmatter.name ?? id),
+      ...frontmatter.description === undefined ? {} : { description: frontmatter.description },
+      ...slash === undefined ? {} : { slash },
+      ...autoinvoke === undefined ? {} : { autoinvoke },
+      location: AbsolutePath.make(filepath),
+      content: markdown.content
+    }
+  };
+}
+
+export { parse, exports_skill_file };

package/dist/chunks/ripgrep-bxdhjb3y.js

@@ -0,0 +1,107 @@
+// src/database/drizzle/sqlite-core/effect/query.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import {
+  makeDefaultRqbMapper
+} from "drizzle-orm/relations";
+import { sql } from "drizzle-orm/sql/sql";
+
+class SQLiteEffectRelationalQueryBuilder {
+  schema;
+  table;
+  tableConfig;
+  dialect;
+  session;
+  rowMode;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectRelationalQueryBuilderV2";
+  constructor(schema, table, tableConfig, dialect, session, rowMode, forbidJsonb) {
+    this.schema = schema;
+    this.table = table;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.rowMode = rowMode;
+    this.forbidJsonb = forbidJsonb;
+  }
+  findMany(config) {
+    return new SQLiteEffectRelationalQuery(this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "many", this.rowMode, this.forbidJsonb);
+  }
+  findFirst(config) {
+    return new SQLiteEffectRelationalQuery(this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "first", this.rowMode, this.forbidJsonb);
+  }
+}
+
+class SQLiteEffectRelationalQuery {
+  schema;
+  tableConfig;
+  dialect;
+  session;
+  config;
+  rowMode;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectRelationalQueryV2";
+  mode;
+  table;
+  constructor(schema, table, tableConfig, dialect, session, config, mode, rowMode, forbidJsonb) {
+    this.schema = schema;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.config = config;
+    this.rowMode = rowMode;
+    this.forbidJsonb = forbidJsonb;
+    this.mode = mode;
+    this.table = table;
+  }
+  getSQL() {
+    return this._getQuery().sql;
+  }
+  _prepare(isOneTimeQuery = true) {
+    const { query, builtQuery } = this._toSQL();
+    const mapperConfig = {
+      isFirst: this.mode === "first",
+      parseJson: !this.rowMode,
+      parseJsonIfString: false,
+      rootJsonMappers: true,
+      selection: query.selection
+    };
+    return this.session[isOneTimeQuery ? "prepareOneTimeRelationalQuery" : "prepareRelationalQuery"](builtQuery, undefined, this.mode === "first" ? "get" : "all", makeDefaultRqbMapper(mapperConfig), mapperConfig);
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  _getQuery() {
+    const jsonb = this.forbidJsonb ? sql`json` : sql`jsonb`;
+    const query = this.dialect.buildRelationalQuery({
+      schema: this.schema,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      mode: this.mode,
+      isNested: this.rowMode,
+      jsonb
+    });
+    if (this.rowMode) {
+      const jsonColumns = sql.join(query.selection.map((s) => {
+        return sql`${sql.raw(this.dialect.escapeString(s.key))}, ${s.selection ? sql`${jsonb}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
+      }), sql`, `);
+      query.sql = sql`select json_object(${jsonColumns}) as ${sql.identifier("r")} from (${query.sql}) as ${sql.identifier("t")}`;
+    }
+    return query;
+  }
+  _toSQL() {
+    const query = this._getQuery();
+    const builtQuery = this.dialect.sqlToQuery(query.sql);
+    return { query, builtQuery };
+  }
+  toSQL() {
+    return this._toSQL().builtQuery;
+  }
+  execute(placeholderValues) {
+    return this.mode === "first" ? this._prepare().get(placeholderValues) : this._prepare().all(placeholderValues);
+  }
+}
+applyEffectWrapper(SQLiteEffectRelationalQuery);
+
+export { SQLiteEffectRelationalQueryBuilder, SQLiteEffectRelationalQuery };

package/dist/chunks/ripgrep-byab506k.js

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

package/dist/chunks/ripgrep-c26sq792.js

@@ -0,0 +1,344 @@
+import {
+  exports_models
+} from "./ripgrep-37rcj8p3.js";
+import {
+  exports_app
+} from "./ripgrep-50jxp3hw.js";
+import {
+  exports_agent
+} from "./ripgrep-4ffc1teg.js";
+import {
+  exports_catalog
+} from "./ripgrep-1cxcv3mr.js";
+import {
+  exports_integration
+} from "./ripgrep-qrmb8ve0.js";
+import {
+  exports_credential
+} from "./ripgrep-padshwcv.js";
+import {
+  exports_model
+} from "./ripgrep-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/provider/github-copilot.ts
+import { Effect, Option, Schema, Semaphore, Stream } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var clientID = "Ov23li8tweQw6odWQebz";
+var apiVersion = "2026-06-01";
+var userApiVersion = "2025-04-01";
+var pollingSafetyMargin = 3000;
+var methodID = exports_integration.MethodID.make("device");
+var Device = Schema.Struct({
+  verification_uri: Schema.String,
+  user_code: Schema.String,
+  device_code: Schema.String,
+  interval: Schema.Number
+});
+var Token = Schema.Struct({
+  access_token: Schema.optional(Schema.String),
+  error: Schema.optional(Schema.String),
+  interval: Schema.optional(Schema.Number)
+});
+var User = Schema.Struct({
+  endpoints: Schema.optional(Schema.Struct({
+    api: Schema.optional(Schema.String)
+  }))
+});
+var decodeUser = Schema.decodeUnknownOption(User);
+var JsonBody = Schema.UnknownFromJsonString;
+var decodeBody = Schema.decodeUnknownOption(JsonBody);
+var oauth = (app) => ({
+  integrationID: exports_integration.ID.make("github-copilot"),
+  method: {
+    id: methodID,
+    type: "oauth",
+    label: "Login with GitHub Copilot",
+    form: [
+      {
+        type: "string",
+        key: "deploymentType",
+        title: "Select GitHub deployment type",
+        required: true,
+        options: [
+          { label: "GitHub.com", value: "github.com", description: "Public" },
+          { label: "GitHub Enterprise", value: "enterprise", description: "Data residency or self-hosted" }
+        ]
+      },
+      {
+        type: "string",
+        key: "enterpriseUrl",
+        title: "Enter your GitHub Enterprise URL or domain",
+        placeholder: "company.ghe.com or https://company.ghe.com",
+        required: true,
+        when: [{ key: "deploymentType", op: "eq", value: "enterprise" }]
+      }
+    ]
+  },
+  authorize: (answer) => Effect.gen(function* () {
+    const enterprise = answer.deploymentType === "enterprise";
+    const enterpriseUrl = typeof answer.enterpriseUrl === "string" ? answer.enterpriseUrl : undefined;
+    if (enterprise && !enterpriseUrl)
+      return yield* Effect.fail(new Error("Enterprise URL is required"));
+    const domain = enterprise ? normalizeDomain(enterpriseUrl ?? "") : "github.com";
+    const urls = oauthURLs(domain);
+    const device = yield* request(urls.device, {
+      method: "POST",
+      headers: headers(app),
+      body: JSON.stringify({ client_id: clientID, scope: "read:user" })
+    }).pipe(Effect.map(Schema.decodeUnknownSync(Device)));
+    const interval = Math.max(device.interval, 1) * 1000;
+    const poll = (wait) => request(urls.token, {
+      method: "POST",
+      headers: headers(app),
+      body: JSON.stringify({
+        client_id: clientID,
+        device_code: device.device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+      })
+    }).pipe(Effect.map(Schema.decodeUnknownSync(Token)), Effect.flatMap((token) => {
+      if (token.access_token) {
+        const access = token.access_token;
+        return request(`${domain === "github.com" ? "https://api.github.com" : `https://api.${domain}`}/copilot_internal/user`, {
+          headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${access}`,
+            "User-Agent": exports_app.useragent(app),
+            "X-GitHub-Api-Version": userApiVersion
+          }
+        }).pipe(Effect.map((user) => Option.getOrUndefined(decodeUser(user))?.endpoints?.api?.replace(/\/+$/, "")), Effect.catch(() => Effect.succeed(undefined)), Effect.map((apiEndpoint) => exports_credential.OAuth.make({
+          type: "oauth",
+          methodID,
+          refresh: access,
+          access,
+          expires: 0,
+          ...(enterprise || apiEndpoint) && {
+            metadata: {
+              ...enterprise ? { enterpriseUrl: domain } : {},
+              ...apiEndpoint ? { apiEndpoint } : {}
+            }
+          }
+        })));
+      }
+      if (token.error === "authorization_pending")
+        return Effect.sleep(wait + pollingSafetyMargin).pipe(Effect.andThen(poll(wait)));
+      if (token.error === "slow_down") {
+        const next = token.interval && token.interval > 0 ? token.interval * 1000 : wait + 5000;
+        return Effect.sleep(next + pollingSafetyMargin).pipe(Effect.andThen(poll(next)));
+      }
+      return Effect.fail(new Error(`Device authorization failed${token.error ? `: ${token.error}` : ""}`));
+    }));
+    return {
+      mode: "auto",
+      url: device.verification_uri,
+      instructions: `Enter code: ${device.user_code}`,
+      callback: poll(interval)
+    };
+  })
+});
+var GithubCopilotPlugin = define({
+  id: "opencode.provider.github-copilot",
+  effect: Effect.fn(function* (ctx) {
+    const catalog = yield* exports_catalog.Service;
+    const bus = yield* exports_bus.Service;
+    const loading = Semaphore.makeUnsafe(1);
+    const loaded = {};
+    const load = Effect.fn("GithubCopilotPlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("github-copilot");
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined))) : undefined;
+      if (credential?.type !== "oauth") {
+        loaded.baseURL = undefined;
+        loaded.models = undefined;
+        return;
+      }
+      loaded.baseURL = copilotBaseURL(credential.metadata);
+      const provider = yield* catalog.provider.get(exports_provider.ID.githubCopilot);
+      const existing = (yield* catalog.model.all()).filter((model) => model.providerID === exports_provider.ID.githubCopilot);
+      loaded.models = yield* Effect.tryPromise({
+        try: () => exports_models.get(loaded.baseURL ?? baseURL(), {
+          ...provider?.headers,
+          Authorization: `Bearer ${credential.refresh}`,
+          "User-Agent": exports_app.useragent(ctx.app),
+          "X-GitHub-Api-Version": apiVersion
+        }, existing),
+        catch: (cause) => cause
+      }).pipe(Effect.catch((cause) => Effect.logWarning("failed to sync GitHub Copilot models", { cause }).pipe(Effect.as(undefined))));
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.method.remove("github-copilot", { type: "key" });
+      draft.method.update(oauth(ctx.app));
+    });
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(exports_provider.ID.githubCopilot);
+      if (!item)
+        return;
+      if (loaded.models) {
+        for (const id of item.models.keys()) {
+          if (!loaded.models.has(exports_model.ID.make(id)))
+            evt.model.remove(item.provider.id, id);
+        }
+        for (const [id, model] of loaded.models) {
+          evt.model.update(item.provider.id, id, (draft) => Object.assign(draft, structuredClone(model)));
+        }
+      } else {
+        for (const id of item.models.keys()) {
+          evt.model.update(item.provider.id, id, (model) => {
+            model.package = "@ai-sdk/github-copilot";
+            if (loaded.baseURL)
+              model.settings = exports_provider.mergeOverlay(model.settings, { baseURL: loaded.baseURL });
+          });
+        }
+      }
+      if (item.models.has(exports_model.ID.make("gpt-5-chat-latest"))) {
+        evt.model.update(item.provider.id, exports_model.ID.make("gpt-5-chat-latest"), (model) => {
+          model.enabled = false;
+        });
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(exports_integration.Event.ConnectionUpdated).pipe(Stream.filter((event) => event.data.integrationID === exports_integration.ID.make("github-copilot")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* refresh().pipe(Effect.forkScoped);
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== exports_provider.ID.githubCopilot)
+        return;
+      if (evt.package !== "@ai-sdk/github-copilot")
+        return;
+      evt.options.fetch = copilotFetch(typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined, evt.options.fetch, ctx.app);
+      const mod = yield* Effect.promise(() => import("../github-copilot/copilot-provider.js"));
+      evt.sdk = mod.createOpenaiCompatible(evt.options);
+    }));
+    yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
+      if (evt.model.providerID !== exports_provider.ID.githubCopilot)
+        return;
+      if (evt.agent === exports_agent.ID.make("title"))
+        evt.request.headers.set("X-Interaction-Type", "conversation-background");
+      if (evt.agent === exports_agent.ID.make("compaction"))
+        evt.request.headers.set("X-Interaction-Type", "conversation-compaction");
+      const token = evt.request.headers.get("x-api-key");
+      if (!token)
+        return;
+      const text = yield* Effect.promise(() => evt.request.clone().text());
+      const body = Option.getOrUndefined(decodeBody(text));
+      applyHeaders(evt.request.headers, token, ctx.app, requestMetadata(evt.request.url, body), true);
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== exports_provider.ID.githubCopilot)
+        return;
+      if (evt.sdk.responses === undefined && evt.sdk.chat === undefined) {
+        evt.language = evt.sdk.languageModel(evt.model.modelID ?? evt.model.id);
+        return;
+      }
+      if (evt.options.endpoint === "responses" && evt.sdk.responses) {
+        evt.language = evt.sdk.responses(evt.model.modelID ?? evt.model.id);
+        return;
+      }
+      if (evt.options.endpoint === "chat" && evt.sdk.chat) {
+        evt.language = evt.sdk.chat(evt.model.modelID ?? evt.model.id);
+        return;
+      }
+      const id = evt.model.modelID ?? evt.model.id;
+      const match = /^gpt-(\d+)/.exec(id);
+      evt.language = match && Number(match[1]) >= 5 && !id.startsWith("gpt-5-mini") ? evt.sdk.responses(id) : evt.sdk.chat(id);
+    }));
+  })
+});
+function normalizeDomain(input) {
+  return input.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+function oauthURLs(domain) {
+  return {
+    device: `https://${domain}/login/device/code`,
+    token: `https://${domain}/login/oauth/access_token`
+  };
+}
+function baseURL(enterprise) {
+  return enterprise ? `https://copilot-api.${normalizeDomain(enterprise)}` : "https://api.githubcopilot.com";
+}
+function copilotBaseURL(metadata) {
+  const endpoint = metadata?.apiEndpoint;
+  if (typeof endpoint === "string" && endpoint)
+    return endpoint;
+  const enterprise = metadata?.enterpriseUrl;
+  return baseURL(typeof enterprise === "string" ? enterprise : undefined);
+}
+function headers(app) {
+  return {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    "User-Agent": exports_app.useragent(app)
+  };
+}
+function request(url, init) {
+  return Effect.tryPromise({
+    try: async (signal) => {
+      const response = await fetch(url, { ...init, signal });
+      if (!response.ok)
+        throw new Error(`Request failed: ${response.status}`);
+      return response.json();
+    },
+    catch: (cause) => cause
+  });
+}
+function copilotFetch(token, upstream, app) {
+  const send = upstream ?? fetch;
+  return async (input, init) => {
+    const requestHeaders = new Headers(init?.headers);
+    const url = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
+    const body = typeof init?.body === "string" ? Option.getOrUndefined(decodeBody(init.body)) : undefined;
+    applyHeaders(requestHeaders, token, app, requestMetadata(url, body), false);
+    return send(input, { ...init, headers: requestHeaders });
+  };
+}
+function applyHeaders(headers2, token, app, metadata, anthropic) {
+  if (token) {
+    headers2.delete("authorization");
+    headers2.delete("x-api-key");
+    headers2.set("Authorization", `Bearer ${token}`);
+  }
+  headers2.set("User-Agent", exports_app.useragent(app));
+  headers2.set("Openai-Intent", "conversation-edits");
+  headers2.set("X-GitHub-Api-Version", apiVersion);
+  headers2.set("x-initiator", metadata.agent ? "agent" : "user");
+  if (metadata.vision)
+    headers2.set("Copilot-Vision-Request", "true");
+  if (anthropic)
+    headers2.set("anthropic-beta", "interleaved-thinking-2025-05-14");
+}
+function requestMetadata(url, body) {
+  if (!record(body))
+    return { agent: false, vision: false };
+  if (Array.isArray(body.input)) {
+    const last2 = body.input.at(-1);
+    return {
+      agent: !record(last2) || last2.role !== "user",
+      vision: body.input.some((item) => record(item) && Array.isArray(item.content) && item.content.some((part) => record(part) && part.type === "input_image"))
+    };
+  }
+  if (!Array.isArray(body.messages))
+    return { agent: false, vision: false };
+  const last = body.messages.at(-1);
+  if (url.includes("completions")) {
+    return {
+      agent: !record(last) || last.role !== "user",
+      vision: body.messages.some((message) => record(message) && Array.isArray(message.content) && message.content.some((part) => record(part) && part.type === "image_url"))
+    };
+  }
+  const content = record(last) && Array.isArray(last.content) ? last.content : [];
+  return {
+    agent: !record(last) || last.role !== "user" || !content.some((part) => record(part) && part.type !== "tool_result"),
+    vision: body.messages.some((message) => record(message) && Array.isArray(message.content) && message.content.some((part) => record(part) && (part.type === "image" || part.type === "tool_result" && Array.isArray(part.content) && part.content.some((nested) => record(nested) && nested.type === "image"))))
+  };
+}
+function record(input) {
+  return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+
+export { GithubCopilotPlugin, copilotBaseURL, copilotFetch };

package/dist/chunks/ripgrep-c77ad0vh.js

@@ -0,0 +1,16 @@
+// src/tool/plugin/file-diff.ts
+import { createTwoFilesPatch, diffLines } from "diff";
+function fileDiff(file, before, after, status = "modified") {
+  const counts = diffLines(before, after).reduce((result, item) => ({
+    additions: result.additions + (item.added ? item.count ?? 0 : 0),
+    deletions: result.deletions + (item.removed ? item.count ?? 0 : 0)
+  }), { additions: 0, deletions: 0 });
+  return {
+    file,
+    patch: createTwoFilesPatch(file, file, before, after),
+    status,
+    ...counts
+  };
+}
+
+export { fileDiff };