@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-gvyf4y9v.js

@@ -0,0 +1,601 @@
+import {
+  convertToOpenAICompatibleChatMessages
+} from "./permission-brsh5f65.js";
+import {
+  mapOpenAICompatibleFinishReason
+} from "./permission-0cgt0xh2.js";
+import {
+  prepareTools
+} from "./permission-ezs3tagn.js";
+import {
+  openaiCompatibleProviderOptions
+} from "./permission-a02svayp.js";
+import {
+  getResponseMetadata
+} from "./permission-bbqs2y60.js";
+import {
+  defaultOpenAICompatibleErrorStructure
+} from "./permission-1wcz8fvj.js";
+
+// src/github-copilot/chat/openai-compatible-chat-language-model.ts
+import {
+  InvalidResponseDataError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  isParsableJson,
+  parseProviderOptions,
+  postJsonToApi
+} from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+class OpenAICompatibleChatLanguageModel {
+  specificationVersion = "v3";
+  supportsStructuredOutputs;
+  modelId;
+  config;
+  failedResponseHandler;
+  chunkSchema;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    const errorStructure = config.errorStructure ?? defaultOpenAICompatibleErrorStructure;
+    this.chunkSchema = createOpenAICompatibleChatChunkSchema(errorStructure.errorSchema);
+    this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
+    this.supportsStructuredOutputs = config.supportsStructuredOutputs ?? false;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  get supportedUrls() {
+    return this.config.supportedUrls?.() ?? {};
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    providerOptions,
+    stopSequences,
+    responseFormat,
+    seed,
+    toolChoice,
+    tools
+  }) {
+    const warnings = [];
+    const compatibleOptions = Object.assign(await parseProviderOptions({
+      provider: "copilot",
+      providerOptions,
+      schema: openaiCompatibleProviderOptions
+    }) ?? {}, await parseProviderOptions({
+      provider: this.providerOptionsName,
+      providerOptions,
+      schema: openaiCompatibleProviderOptions
+    }) ?? {});
+    if (topK != null) {
+      warnings.push({ type: "unsupported", feature: "topK" });
+    }
+    if (responseFormat?.type === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
+      warnings.push({
+        type: "unsupported",
+        feature: "responseFormat",
+        details: "JSON response format schema is only supported with structuredOutputs"
+      });
+    }
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      toolWarnings
+    } = prepareTools({
+      tools,
+      toolChoice
+    });
+    return {
+      args: {
+        model: this.modelId,
+        user: compatibleOptions.user,
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        response_format: responseFormat?.type === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
+          type: "json_schema",
+          json_schema: {
+            schema: responseFormat.schema,
+            name: responseFormat.name ?? "response",
+            description: responseFormat.description
+          }
+        } : { type: "json_object" } : undefined,
+        stop: stopSequences,
+        seed,
+        ...Object.fromEntries(Object.entries(providerOptions?.[this.providerOptionsName] ?? {}).filter(([key]) => !Object.keys(openaiCompatibleProviderOptions.shape).includes(key))),
+        reasoning_effort: compatibleOptions.reasoningEffort,
+        verbosity: compatibleOptions.textVerbosity,
+        messages: convertToOpenAICompatibleChatMessages(prompt),
+        tools: openaiTools,
+        tool_choice: openaiToolChoice,
+        thinking_budget: compatibleOptions.thinking_budget
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
+  }
+  async doGenerate(options) {
+    const { args, warnings } = await this.getArgs({ ...options });
+    const body = JSON.stringify(args);
+    const {
+      responseHeaders,
+      value: responseBody,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(OpenAICompatibleChatResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = responseBody.choices[0];
+    const content = [];
+    const text = choice.message.content;
+    if (text != null && text.length > 0) {
+      content.push({
+        type: "text",
+        text,
+        providerMetadata: choice.message.reasoning_opaque ? { copilot: { reasoningOpaque: choice.message.reasoning_opaque } } : undefined
+      });
+    }
+    const reasoning = choice.message.reasoning_text;
+    if (reasoning != null && reasoning.length > 0) {
+      content.push({
+        type: "reasoning",
+        text: reasoning,
+        providerMetadata: choice.message.reasoning_opaque ? { copilot: { reasoningOpaque: choice.message.reasoning_opaque } } : undefined
+      });
+    }
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: toolCall.id ?? generateId(),
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments,
+          providerMetadata: choice.message.reasoning_opaque ? { copilot: { reasoningOpaque: choice.message.reasoning_opaque } } : undefined
+        });
+      }
+    }
+    const providerMetadata = {
+      [this.providerOptionsName]: {},
+      ...await this.config.metadataExtractor?.extractMetadata?.({
+        parsedBody: rawResponse
+      })
+    };
+    const completionTokenDetails = responseBody.usage?.completion_tokens_details;
+    if (completionTokenDetails?.accepted_prediction_tokens != null) {
+      providerMetadata[this.providerOptionsName].acceptedPredictionTokens = completionTokenDetails?.accepted_prediction_tokens;
+    }
+    if (completionTokenDetails?.rejected_prediction_tokens != null) {
+      providerMetadata[this.providerOptionsName].rejectedPredictionTokens = completionTokenDetails?.rejected_prediction_tokens;
+    }
+    return {
+      content,
+      finishReason: {
+        unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+        raw: choice.finish_reason ?? undefined
+      },
+      usage: {
+        inputTokens: {
+          total: responseBody.usage?.prompt_tokens ?? undefined,
+          noCache: undefined,
+          cacheRead: responseBody.usage?.prompt_tokens_details?.cached_tokens ?? undefined,
+          cacheWrite: undefined
+        },
+        outputTokens: {
+          total: responseBody.usage?.completion_tokens ?? undefined,
+          text: undefined,
+          reasoning: responseBody.usage?.completion_tokens_details?.reasoning_tokens ?? undefined
+        },
+        raw: responseBody.usage ?? undefined
+      },
+      providerMetadata,
+      request: { body },
+      response: {
+        ...getResponseMetadata(responseBody),
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      warnings
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = await this.getArgs({ ...options });
+    const body = {
+      ...args,
+      stream: true,
+      stream_options: this.config.includeUsage ? { include_usage: true } : undefined
+    };
+    const metadataExtractor = this.config.metadataExtractor?.createStreamExtractor();
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(this.chunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const toolCalls = [];
+    let finishReason = {
+      unified: "other",
+      raw: undefined
+    };
+    const usage = {
+      completionTokens: undefined,
+      completionTokensDetails: {
+        reasoningTokens: undefined,
+        acceptedPredictionTokens: undefined,
+        rejectedPredictionTokens: undefined
+      },
+      promptTokens: undefined,
+      promptTokensDetails: {
+        cachedTokens: undefined
+      },
+      totalTokens: undefined
+    };
+    let isFirstChunk = true;
+    const providerOptionsName = this.providerOptionsName;
+    let isActiveReasoning = false;
+    let isActiveText = false;
+    let reasoningOpaque;
+    return {
+      stream: response.pipeThrough(new TransformStream({
+        start(controller) {
+          controller.enqueue({ type: "stream-start", warnings });
+        },
+        transform(chunk, controller) {
+          if (options.includeRawChunks) {
+            controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+          }
+          if (!chunk.success) {
+            finishReason = {
+              unified: "error",
+              raw: undefined
+            };
+            controller.enqueue({ type: "error", error: chunk.error });
+            return;
+          }
+          const value = chunk.value;
+          metadataExtractor?.processChunk(chunk.rawValue);
+          if ("error" in value) {
+            finishReason = {
+              unified: "error",
+              raw: undefined
+            };
+            controller.enqueue({ type: "error", error: value.error.message });
+            return;
+          }
+          if (isFirstChunk) {
+            isFirstChunk = false;
+            controller.enqueue({
+              type: "response-metadata",
+              ...getResponseMetadata(value)
+            });
+          }
+          if (value.usage != null) {
+            const {
+              prompt_tokens,
+              completion_tokens,
+              total_tokens,
+              prompt_tokens_details,
+              completion_tokens_details
+            } = value.usage;
+            usage.promptTokens = prompt_tokens ?? undefined;
+            usage.completionTokens = completion_tokens ?? undefined;
+            usage.totalTokens = total_tokens ?? undefined;
+            if (completion_tokens_details?.reasoning_tokens != null) {
+              usage.completionTokensDetails.reasoningTokens = completion_tokens_details?.reasoning_tokens;
+            }
+            if (completion_tokens_details?.accepted_prediction_tokens != null) {
+              usage.completionTokensDetails.acceptedPredictionTokens = completion_tokens_details?.accepted_prediction_tokens;
+            }
+            if (completion_tokens_details?.rejected_prediction_tokens != null) {
+              usage.completionTokensDetails.rejectedPredictionTokens = completion_tokens_details?.rejected_prediction_tokens;
+            }
+            if (prompt_tokens_details?.cached_tokens != null) {
+              usage.promptTokensDetails.cachedTokens = prompt_tokens_details?.cached_tokens;
+            }
+          }
+          const choice = value.choices[0];
+          if (choice?.finish_reason != null) {
+            finishReason = {
+              unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+              raw: choice.finish_reason ?? undefined
+            };
+          }
+          if (choice?.delta == null) {
+            return;
+          }
+          const delta = choice.delta;
+          if (delta.reasoning_opaque) {
+            if (reasoningOpaque != null) {
+              throw new InvalidResponseDataError({
+                data: delta,
+                message: "Multiple reasoning_opaque values received in a single response. Only one thinking part per response is supported."
+              });
+            }
+            reasoningOpaque = delta.reasoning_opaque;
+          }
+          const reasoningContent = delta.reasoning_text;
+          if (reasoningContent) {
+            if (!isActiveReasoning) {
+              controller.enqueue({
+                type: "reasoning-start",
+                id: "reasoning-0"
+              });
+              isActiveReasoning = true;
+            }
+            controller.enqueue({
+              type: "reasoning-delta",
+              id: "reasoning-0",
+              delta: reasoningContent
+            });
+          }
+          if (delta.content) {
+            if (isActiveReasoning && !isActiveText) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: "reasoning-0",
+                providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+              });
+              isActiveReasoning = false;
+            }
+            if (!isActiveText) {
+              controller.enqueue({
+                type: "text-start",
+                id: "txt-0",
+                providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+              });
+              isActiveText = true;
+            }
+            controller.enqueue({
+              type: "text-delta",
+              id: "txt-0",
+              delta: delta.content
+            });
+          }
+          if (delta.tool_calls != null) {
+            if (isActiveReasoning) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: "reasoning-0",
+                providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+              });
+              isActiveReasoning = false;
+            }
+            for (const toolCallDelta of delta.tool_calls) {
+              const index = toolCallDelta.index;
+              if (toolCalls[index] == null) {
+                if (toolCallDelta.id == null) {
+                  throw new InvalidResponseDataError({
+                    data: toolCallDelta,
+                    message: `Expected 'id' to be a string.`
+                  });
+                }
+                if (toolCallDelta.function?.name == null) {
+                  throw new InvalidResponseDataError({
+                    data: toolCallDelta,
+                    message: `Expected 'function.name' to be a string.`
+                  });
+                }
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: toolCallDelta.id,
+                  toolName: toolCallDelta.function.name
+                });
+                toolCalls[index] = {
+                  id: toolCallDelta.id,
+                  type: "function",
+                  function: {
+                    name: toolCallDelta.function.name,
+                    arguments: toolCallDelta.function.arguments ?? ""
+                  },
+                  hasFinished: false
+                };
+                const toolCall2 = toolCalls[index];
+                if (toolCall2.function?.name != null && toolCall2.function?.arguments != null) {
+                  if (toolCall2.function.arguments.length > 0) {
+                    controller.enqueue({
+                      type: "tool-input-delta",
+                      id: toolCall2.id,
+                      delta: toolCall2.function.arguments
+                    });
+                  }
+                  if (isParsableJson(toolCall2.function.arguments)) {
+                    controller.enqueue({
+                      type: "tool-input-end",
+                      id: toolCall2.id
+                    });
+                    controller.enqueue({
+                      type: "tool-call",
+                      toolCallId: toolCall2.id ?? generateId(),
+                      toolName: toolCall2.function.name,
+                      input: toolCall2.function.arguments,
+                      providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+                    });
+                    toolCall2.hasFinished = true;
+                  }
+                }
+                continue;
+              }
+              const toolCall = toolCalls[index];
+              if (toolCall.hasFinished) {
+                continue;
+              }
+              if (toolCallDelta.function?.arguments != null) {
+                toolCall.function.arguments += toolCallDelta.function?.arguments ?? "";
+              }
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: toolCall.id,
+                delta: toolCallDelta.function.arguments ?? ""
+              });
+              if (toolCall.function?.name != null && toolCall.function?.arguments != null && isParsableJson(toolCall.function.arguments)) {
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: toolCall.id
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: toolCall.id ?? generateId(),
+                  toolName: toolCall.function.name,
+                  input: toolCall.function.arguments,
+                  providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+                });
+                toolCall.hasFinished = true;
+              }
+            }
+          }
+        },
+        flush(controller) {
+          if (isActiveReasoning) {
+            controller.enqueue({
+              type: "reasoning-end",
+              id: "reasoning-0",
+              providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined
+            });
+          }
+          if (isActiveText) {
+            controller.enqueue({ type: "text-end", id: "txt-0" });
+          }
+          for (const toolCall of toolCalls.filter((toolCall2) => !toolCall2.hasFinished)) {
+            controller.enqueue({
+              type: "tool-input-end",
+              id: toolCall.id
+            });
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: toolCall.id ?? generateId(),
+              toolName: toolCall.function.name,
+              input: toolCall.function.arguments
+            });
+          }
+          const providerMetadata = {
+            [providerOptionsName]: {},
+            ...reasoningOpaque ? { copilot: { reasoningOpaque } } : {},
+            ...metadataExtractor?.buildMetadata()
+          };
+          if (usage.completionTokensDetails.acceptedPredictionTokens != null) {
+            providerMetadata[providerOptionsName].acceptedPredictionTokens = usage.completionTokensDetails.acceptedPredictionTokens;
+          }
+          if (usage.completionTokensDetails.rejectedPredictionTokens != null) {
+            providerMetadata[providerOptionsName].rejectedPredictionTokens = usage.completionTokensDetails.rejectedPredictionTokens;
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason,
+            usage: {
+              inputTokens: {
+                total: usage.promptTokens,
+                noCache: usage.promptTokens != null && usage.promptTokensDetails.cachedTokens != null ? usage.promptTokens - usage.promptTokensDetails.cachedTokens : undefined,
+                cacheRead: usage.promptTokensDetails.cachedTokens,
+                cacheWrite: undefined
+              },
+              outputTokens: {
+                total: usage.completionTokens,
+                text: undefined,
+                reasoning: usage.completionTokensDetails.reasoningTokens
+              },
+              raw: {
+                prompt_tokens: usage.promptTokens ?? null,
+                completion_tokens: usage.completionTokens ?? null,
+                total_tokens: usage.totalTokens ?? null
+              }
+            },
+            providerMetadata
+          });
+        }
+      })),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+}
+var openaiCompatibleTokenUsageSchema = z.object({
+  prompt_tokens: z.number().nullish(),
+  completion_tokens: z.number().nullish(),
+  total_tokens: z.number().nullish(),
+  prompt_tokens_details: z.object({
+    cached_tokens: z.number().nullish()
+  }).nullish(),
+  completion_tokens_details: z.object({
+    reasoning_tokens: z.number().nullish(),
+    accepted_prediction_tokens: z.number().nullish(),
+    rejected_prediction_tokens: z.number().nullish()
+  }).nullish()
+}).nullish();
+var OpenAICompatibleChatResponseSchema = z.object({
+  id: z.string().nullish(),
+  created: z.number().nullish(),
+  model: z.string().nullish(),
+  choices: z.array(z.object({
+    message: z.object({
+      role: z.literal("assistant").nullish(),
+      content: z.string().nullish(),
+      reasoning_text: z.string().nullish(),
+      reasoning_opaque: z.string().nullish(),
+      tool_calls: z.array(z.object({
+        id: z.string().nullish(),
+        function: z.object({
+          name: z.string(),
+          arguments: z.string()
+        })
+      })).nullish()
+    }),
+    finish_reason: z.string().nullish()
+  })),
+  usage: openaiCompatibleTokenUsageSchema
+});
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => z.union([
+  z.object({
+    id: z.string().nullish(),
+    created: z.number().nullish(),
+    model: z.string().nullish(),
+    choices: z.array(z.object({
+      delta: z.object({
+        role: z.enum(["assistant"]).nullish(),
+        content: z.string().nullish(),
+        reasoning_text: z.string().nullish(),
+        reasoning_opaque: z.string().nullish(),
+        tool_calls: z.array(z.object({
+          index: z.number(),
+          id: z.string().nullish(),
+          function: z.object({
+            name: z.string().nullish(),
+            arguments: z.string().nullish()
+          })
+        })).nullish()
+      }).nullish(),
+      finish_reason: z.string().nullish()
+    })),
+    usage: openaiCompatibleTokenUsageSchema
+  }),
+  errorSchema
+]);
+
+export { OpenAICompatibleChatLanguageModel };

package/dist/chunks/permission-gxp1x3zs.js

@@ -0,0 +1,21 @@
+import {
+  exports_catalog
+} from "./permission-849eva8b.js";
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+
+// src/plugin/provider/configured.ts
+import { Effect, Option } from "effect";
+var configuredSettings = Effect.fn("ProviderPlugin.configuredSettings")(function* (id) {
+  const catalog = yield* exports_catalog.Service;
+  const current = (yield* catalog.provider.get(id))?.settings;
+  const service = yield* Effect.serviceOption(exports_config.Service);
+  const entries = Option.isSome(service) ? yield* service.value.entries() : [];
+  return entries.filter((entry) => entry.type === "document").reduce((settings, entry) => exports_provider.mergeOverlay(settings, entry.info.providers?.[id]?.settings), current);
+});
+
+export { configuredSettings };

package/dist/chunks/permission-gy500k2r.js

@@ -0,0 +1,17 @@
+// src/github-copilot/responses/tool/web-search.ts
+import { z } from "zod/v4";
+var webSearchArgsSchema = 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 { webSearchArgsSchema };