@opencode/core 0.0.0-reserved → 2.0.1

package/dist/types/git.d.ts

@@ -0,0 +1,134 @@
+export * as Git from "./git.js";
+import { Context, Effect, Schema } from "effect";
+import { AbsolutePath, RelativePath } from "./schema.js";
+import { File } from "./file.js";
+declare const Repository_base: Schema.Class<Repository, Schema.Struct<{
+    readonly worktree: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly gitDirectory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly commonDirectory: Schema.brand<Schema.String, "AbsolutePath">;
+}>, {}>;
+export declare class Repository extends Repository_base {
+}
+export declare const TreeID: Schema.brand<Schema.String, "Git.TreeID">;
+export type TreeID = typeof TreeID.Type;
+declare const OperationError_base: Schema.Class<OperationError, Schema.TaggedStruct<"Git.OperationError", {
+    readonly operation: Schema.Literals<readonly ["clone", "fetch", "checkout", "reset", "create", "refresh", "write_tree", "list_files", "diff", "restore"]>;
+    readonly message: Schema.String;
+    readonly directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class OperationError extends OperationError_base {
+}
+declare const Worktree_base: Schema.Class<Worktree, Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly kind: Schema.Literals<readonly ["main", "linked"]>;
+}>, {}>;
+export declare class Worktree extends Worktree_base {
+}
+declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.TaggedStruct<"Git.WorktreeError", {
+    readonly operation: Schema.Literals<readonly ["create", "remove", "list"]>;
+    readonly message: Schema.String;
+    readonly directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
+    readonly forceRequired: Schema.optional<Schema.Boolean>;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorktreeError extends WorktreeError_base {
+}
+export interface Interface {
+    readonly repo: {
+        readonly discover: (input: AbsolutePath) => Effect.Effect<Repository | undefined>;
+        readonly clone: (input: {
+            remote: string;
+            directory: AbsolutePath;
+            branch?: string;
+            depth?: number;
+        }) => Effect.Effect<Repository, OperationError>;
+        readonly create: (input: {
+            worktree: AbsolutePath;
+            gitDirectory: AbsolutePath;
+            seed?: Repository;
+        }) => Effect.Effect<Repository, OperationError>;
+    };
+    readonly remote: {
+        readonly get: (repository: Repository, name?: string) => Effect.Effect<string | undefined>;
+    };
+    readonly history: {
+        readonly head: (repository: Repository) => Effect.Effect<string | undefined>;
+        readonly branch: (repository: Repository) => Effect.Effect<string | undefined>;
+        readonly defaultRemoteBranch: (repository: Repository, remote?: string) => Effect.Effect<string | undefined>;
+        readonly rootCommits: (repository: Repository) => Effect.Effect<readonly string[]>;
+    };
+    readonly sync: {
+        readonly fetchRemotes: (repository: Repository, input?: {
+            prune?: boolean;
+        }) => Effect.Effect<void, OperationError>;
+        readonly fetchBranch: (repository: Repository, input: {
+            remote?: string;
+            branch: string;
+            force?: boolean;
+        }) => Effect.Effect<void, OperationError>;
+        readonly checkoutRemoteBranch: (repository: Repository, input: {
+            remote?: string;
+            branch: string;
+            reset?: boolean;
+        }) => Effect.Effect<void, OperationError>;
+        readonly resetHard: (repository: Repository, revision: string) => Effect.Effect<void, OperationError>;
+    };
+    readonly worktree: {
+        readonly create: (input: {
+            repository: Repository;
+            directory: AbsolutePath;
+            ref?: string;
+        }) => Effect.Effect<Repository, WorktreeError>;
+        readonly remove: (input: {
+            repository: Repository;
+            directory: AbsolutePath;
+            force: boolean;
+        }) => Effect.Effect<void, WorktreeError>;
+        readonly list: (repository: Repository) => Effect.Effect<readonly Worktree[], WorktreeError>;
+    };
+    readonly index: {
+        /** Refresh only the requested project-relative scope, preserving all other entries. */
+        readonly refresh: (input: {
+            repository: Repository;
+            scope: RelativePath;
+            ignores?: Repository;
+            maximumUntrackedFileBytes?: number;
+        }) => Effect.Effect<{
+            readonly skipped: readonly RelativePath[];
+        }, OperationError>;
+        readonly ignored: (input: {
+            repository: Repository;
+            paths: readonly RelativePath[];
+        }) => Effect.Effect<ReadonlySet<RelativePath>, OperationError>;
+    };
+    readonly tree: {
+        readonly capture: (input: {
+            repository: Repository;
+            scopes: readonly RelativePath[];
+            ignores?: Repository;
+            maximumUntrackedFileBytes?: number;
+        }) => Effect.Effect<TreeID, OperationError>;
+        readonly write: (repository: Repository) => Effect.Effect<TreeID, OperationError>;
+        readonly files: (input: {
+            repository: Repository;
+            from: TreeID;
+            to: TreeID;
+        }) => Effect.Effect<readonly RelativePath[], OperationError>;
+        readonly diff: (input: {
+            repository: Repository;
+            from: TreeID;
+            to: TreeID;
+            context?: number;
+            paths?: readonly RelativePath[];
+        }) => Effect.Effect<readonly File.Diff[], OperationError>;
+        readonly restore: (input: {
+            repository: Repository;
+            files: ReadonlyMap<RelativePath, TreeID>;
+        }) => Effect.Effect<void, OperationError>;
+    };
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Git", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/github-copilot/chat/convert-to-openai-compatible-chat-messages.d.ts

@@ -0,0 +1,3 @@
+import { type LanguageModelV3Prompt } from "@ai-sdk/provider";
+import type { OpenAICompatibleChatPrompt } from "./openai-compatible-api-types.js";
+export declare function convertToOpenAICompatibleChatMessages(prompt: LanguageModelV3Prompt): OpenAICompatibleChatPrompt;

package/dist/types/github-copilot/chat/get-response-metadata.d.ts

@@ -0,0 +1,9 @@
+export declare function getResponseMetadata({ id, model, created, }: {
+    id?: string | undefined | null;
+    created?: number | undefined | null;
+    model?: string | undefined | null;
+}): {
+    id: string | undefined;
+    modelId: string | undefined;
+    timestamp: Date | undefined;
+};

package/dist/types/github-copilot/chat/map-openai-compatible-finish-reason.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModelV3FinishReason } from "@ai-sdk/provider";
+export declare function mapOpenAICompatibleFinishReason(finishReason: string | null | undefined): LanguageModelV3FinishReason["unified"];

package/dist/types/github-copilot/chat/openai-compatible-api-types.d.ts

@@ -0,0 +1,48 @@
+import type { JSONValue } from "@ai-sdk/provider";
+export type OpenAICompatibleChatPrompt = Array<OpenAICompatibleMessage>;
+export type OpenAICompatibleMessage = OpenAICompatibleSystemMessage | OpenAICompatibleUserMessage | OpenAICompatibleAssistantMessage | OpenAICompatibleToolMessage;
+type JsonRecord<T = never> = Record<string, JSONValue | JSONValue[] | T | T[] | undefined>;
+export interface OpenAICompatibleSystemMessage extends JsonRecord<OpenAICompatibleSystemContentPart> {
+    role: "system";
+    content: string | Array<OpenAICompatibleSystemContentPart>;
+}
+export interface OpenAICompatibleSystemContentPart extends JsonRecord {
+    type: "text";
+    text: string;
+}
+export interface OpenAICompatibleUserMessage extends JsonRecord<OpenAICompatibleContentPart> {
+    role: "user";
+    content: string | Array<OpenAICompatibleContentPart>;
+}
+export type OpenAICompatibleContentPart = OpenAICompatibleContentPartText | OpenAICompatibleContentPartImage;
+export interface OpenAICompatibleContentPartImage extends JsonRecord {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+}
+export interface OpenAICompatibleContentPartText extends JsonRecord {
+    type: "text";
+    text: string;
+}
+export interface OpenAICompatibleAssistantMessage extends JsonRecord<OpenAICompatibleMessageToolCall> {
+    role: "assistant";
+    content?: string | null;
+    tool_calls?: Array<OpenAICompatibleMessageToolCall>;
+    reasoning_text?: string;
+    reasoning_opaque?: string;
+}
+export interface OpenAICompatibleMessageToolCall extends JsonRecord {
+    type: "function";
+    id: string;
+    function: {
+        arguments: string;
+        name: string;
+    };
+}
+export interface OpenAICompatibleToolMessage extends JsonRecord {
+    role: "tool";
+    content: string;
+    tool_call_id: string;
+}
+export {};

package/dist/types/github-copilot/chat/openai-compatible-chat-language-model.d.ts

@@ -0,0 +1,135 @@
+import { type LanguageModelV3, type LanguageModelV3CallOptions, type LanguageModelV3Content, type LanguageModelV3StreamPart, type SharedV3ProviderMetadata, type SharedV3Warning } from "@ai-sdk/provider";
+import { type FetchFunction } from "@ai-sdk/provider-utils";
+import { type OpenAICompatibleChatModelId } from "./openai-compatible-chat-options.js";
+import { type ProviderErrorStructure } from "../openai-compatible-error.js";
+import type { MetadataExtractor } from "./openai-compatible-metadata-extractor.js";
+export type OpenAICompatibleChatConfig = {
+    provider: string;
+    headers: () => Record<string, string | undefined>;
+    url: (options: {
+        modelId: string;
+        path: string;
+    }) => string;
+    fetch?: FetchFunction;
+    includeUsage?: boolean;
+    errorStructure?: ProviderErrorStructure<any>;
+    metadataExtractor?: MetadataExtractor;
+    /**
+     * Whether the model supports structured outputs.
+     */
+    supportsStructuredOutputs?: boolean;
+    /**
+     * The supported URLs for the model.
+     */
+    supportedUrls?: () => LanguageModelV3["supportedUrls"];
+};
+export declare class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
+    readonly specificationVersion = "v3";
+    readonly supportsStructuredOutputs: boolean;
+    readonly modelId: OpenAICompatibleChatModelId;
+    private readonly config;
+    private readonly failedResponseHandler;
+    private readonly chunkSchema;
+    constructor(modelId: OpenAICompatibleChatModelId, config: OpenAICompatibleChatConfig);
+    get provider(): string;
+    private get providerOptionsName();
+    get supportedUrls(): Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>>;
+    private getArgs;
+    doGenerate(options: LanguageModelV3CallOptions): Promise<{
+        content: LanguageModelV3Content[];
+        finishReason: {
+            unified: "length" | "error" | "stop" | "tool-calls" | "content-filter" | "other";
+            raw: string | undefined;
+        };
+        usage: {
+            inputTokens: {
+                total: number | undefined;
+                noCache: undefined;
+                cacheRead: number | undefined;
+                cacheWrite: undefined;
+            };
+            outputTokens: {
+                total: number | undefined;
+                text: undefined;
+                reasoning: number | undefined;
+            };
+            raw: {
+                prompt_tokens?: number | null | undefined;
+                completion_tokens?: number | null | undefined;
+                total_tokens?: number | null | undefined;
+                prompt_tokens_details?: {
+                    cached_tokens?: number | null | undefined;
+                } | null | undefined;
+                completion_tokens_details?: {
+                    reasoning_tokens?: number | null | undefined;
+                    accepted_prediction_tokens?: number | null | undefined;
+                    rejected_prediction_tokens?: number | null | undefined;
+                } | null | undefined;
+            } | undefined;
+        };
+        providerMetadata: SharedV3ProviderMetadata;
+        request: {
+            body: string;
+        };
+        response: {
+            headers: Record<string, string> | undefined;
+            body: unknown;
+            id: string | undefined;
+            modelId: string | undefined;
+            timestamp: Date | undefined;
+        };
+        warnings: SharedV3Warning[];
+    }>;
+    doStream(options: LanguageModelV3CallOptions): Promise<{
+        stream: import("stream/web").ReadableStream<LanguageModelV3StreamPart>;
+        request: {
+            body: {
+                stream: boolean;
+                stream_options: {
+                    include_usage: boolean;
+                } | undefined;
+                reasoning_effort: string | undefined;
+                verbosity: string | undefined;
+                messages: import("./openai-compatible-api-types.js").OpenAICompatibleChatPrompt;
+                tools: {
+                    type: "function";
+                    function: {
+                        name: string;
+                        description: string | undefined;
+                        parameters: unknown;
+                    };
+                }[] | undefined;
+                tool_choice: "required" | "auto" | "none" | {
+                    type: "function";
+                    function: {
+                        name: string;
+                    };
+                } | undefined;
+                thinking_budget: number | undefined;
+                model: string;
+                user: string | undefined;
+                max_tokens: number | undefined;
+                temperature: number | undefined;
+                top_p: number | undefined;
+                frequency_penalty: number | undefined;
+                presence_penalty: number | undefined;
+                response_format: {
+                    type: string;
+                    json_schema: {
+                        schema: import("@ai-sdk/provider").JSONSchema7;
+                        name: string;
+                        description: string | undefined;
+                    };
+                } | {
+                    type: string;
+                    json_schema?: undefined;
+                } | undefined;
+                stop: string[] | undefined;
+                seed: number | undefined;
+            };
+        };
+        response: {
+            headers: Record<string, string> | undefined;
+        };
+    }>;
+}

package/dist/types/github-copilot/chat/openai-compatible-chat-options.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+export type OpenAICompatibleChatModelId = string;
+export declare const openaiCompatibleProviderOptions: z.ZodObject<{
+    user: z.ZodOptional<z.ZodString>;
+    reasoningEffort: z.ZodOptional<z.ZodString>;
+    textVerbosity: z.ZodOptional<z.ZodString>;
+    thinking_budget: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type OpenAICompatibleProviderOptions = z.infer<typeof openaiCompatibleProviderOptions>;

package/dist/types/github-copilot/chat/openai-compatible-metadata-extractor.d.ts

@@ -0,0 +1,43 @@
+import type { SharedV3ProviderMetadata } from "@ai-sdk/provider";
+/**
+Extracts provider-specific metadata from API responses.
+Used to standardize metadata handling across different LLM providers while allowing
+provider-specific metadata to be captured.
+*/
+export type MetadataExtractor = {
+    /**
+     * Extracts provider metadata from a complete, non-streaming response.
+     *
+     * @param parsedBody - The parsed response JSON body from the provider's API.
+     *
+     * @returns Provider-specific metadata or undefined if no metadata is available.
+     *          The metadata should be under a key indicating the provider id.
+     */
+    extractMetadata: ({ parsedBody }: {
+        parsedBody: unknown;
+    }) => Promise<SharedV3ProviderMetadata | undefined>;
+    /**
+     * Creates an extractor for handling streaming responses. The returned object provides
+     * methods to process individual chunks and build the final metadata from the accumulated
+     * stream data.
+     *
+     * @returns An object with methods to process chunks and build metadata from a stream
+     */
+    createStreamExtractor: () => {
+        /**
+         * Process an individual chunk from the stream. Called for each chunk in the response stream
+         * to accumulate metadata throughout the streaming process.
+         *
+         * @param parsedChunk - The parsed JSON response chunk from the provider's API
+         */
+        processChunk(parsedChunk: unknown): void;
+        /**
+         * Builds the metadata object after all chunks have been processed.
+         * Called at the end of the stream to generate the complete provider metadata.
+         *
+         * @returns Provider-specific metadata or undefined if no metadata is available.
+         *          The metadata should be under a key indicating the provider id.
+         */
+        buildMetadata(): SharedV3ProviderMetadata | undefined;
+    };
+};

package/dist/types/github-copilot/chat/openai-compatible-prepare-tools.d.ts

@@ -0,0 +1,21 @@
+import { type LanguageModelV3CallOptions, type SharedV3Warning } from "@ai-sdk/provider";
+export declare function prepareTools({ tools, toolChoice, }: {
+    tools: LanguageModelV3CallOptions["tools"];
+    toolChoice?: LanguageModelV3CallOptions["toolChoice"];
+}): {
+    tools: undefined | Array<{
+        type: "function";
+        function: {
+            name: string;
+            description: string | undefined;
+            parameters: unknown;
+        };
+    }>;
+    toolChoice: {
+        type: "function";
+        function: {
+            name: string;
+        };
+    } | "auto" | "none" | "required" | undefined;
+    toolWarnings: SharedV3Warning[];
+};

package/dist/types/github-copilot/copilot-provider.d.ts

@@ -0,0 +1,36 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import { type FetchFunction } from "@ai-sdk/provider-utils";
+export type OpenaiCompatibleModelId = string;
+export interface OpenaiCompatibleProviderSettings {
+    /**
+     * API key for authenticating requests.
+     */
+    apiKey?: string;
+    /**
+     * Base URL for the OpenAI Compatible API calls.
+     */
+    baseURL?: string;
+    /**
+     * Name of the provider.
+     */
+    name?: string;
+    /**
+     * Custom headers to include in the requests.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Custom fetch implementation.
+     */
+    fetch?: FetchFunction;
+}
+export interface OpenaiCompatibleProvider {
+    (modelId: OpenaiCompatibleModelId): LanguageModelV3;
+    chat(modelId: OpenaiCompatibleModelId): LanguageModelV3;
+    responses(modelId: OpenaiCompatibleModelId): LanguageModelV3;
+    languageModel(modelId: OpenaiCompatibleModelId): LanguageModelV3;
+}
+/**
+ * Create an OpenAI Compatible provider instance.
+ */
+export declare function createOpenaiCompatible(options?: OpenaiCompatibleProviderSettings): OpenaiCompatibleProvider;
+export declare const openaiCompatible: OpenaiCompatibleProvider;

package/dist/types/github-copilot/models.d.ts

@@ -0,0 +1,3 @@
+export * as CopilotModels from "./models.js";
+import { Model } from "../model.js";
+export declare function get(baseURL: string, headers: RequestInit["headers"], existing: readonly Model.Info[]): Promise<Map<string & import("effect/Brand").Brand<"Model.ID">, import("@opencode/schema/model").Info>>;

package/dist/types/github-copilot/openai-compatible-error.d.ts

@@ -0,0 +1,16 @@
+import { z, type ZodType } from "zod/v4";
+export declare const openaiCompatibleErrorDataSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        message: z.ZodString;
+        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        param: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+        code: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type OpenAICompatibleErrorData = z.infer<typeof openaiCompatibleErrorDataSchema>;
+export type ProviderErrorStructure<T> = {
+    errorSchema: ZodType<T>;
+    errorToMessage: (error: T) => string;
+    isRetryable?: (response: Response, error?: T) => boolean;
+};
+export declare const defaultOpenAICompatibleErrorStructure: ProviderErrorStructure<OpenAICompatibleErrorData>;

package/dist/types/github-copilot/responses/convert-to-openai-responses-input.d.ts

@@ -0,0 +1,18 @@
+import { type LanguageModelV3Prompt, type SharedV3Warning } from "@ai-sdk/provider";
+import { z } from "zod/v4";
+import type { OpenAIResponsesInput } from "./openai-responses-api-types.js";
+export declare function convertToOpenAIResponsesInput({ prompt, systemMessageMode, fileIdPrefixes, store, }: {
+    prompt: LanguageModelV3Prompt;
+    systemMessageMode: "system" | "developer" | "remove";
+    fileIdPrefixes?: readonly string[];
+    store: boolean;
+}): Promise<{
+    input: OpenAIResponsesInput;
+    warnings: Array<SharedV3Warning>;
+}>;
+declare const openaiResponsesReasoningProviderOptionsSchema: z.ZodObject<{
+    itemId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reasoningEncryptedContent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type OpenAIResponsesReasoningProviderOptions = z.infer<typeof openaiResponsesReasoningProviderOptionsSchema>;
+export {};

package/dist/types/github-copilot/responses/map-openai-responses-finish-reason.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageModelV3FinishReason } from "@ai-sdk/provider";
+export declare function mapOpenAIResponseFinishReason({ finishReason, hasFunctionCall, }: {
+    finishReason: string | null | undefined;
+    hasFunctionCall: boolean;
+}): LanguageModelV3FinishReason["unified"];

package/dist/types/github-copilot/responses/openai-config.d.ts

@@ -0,0 +1,20 @@
+import type { FetchFunction } from "@ai-sdk/provider-utils";
+export type OpenAIConfig = {
+    provider: string;
+    url: (options: {
+        modelId: string;
+        path: string;
+    }) => string;
+    headers: () => Record<string, string | undefined>;
+    fetch?: FetchFunction;
+    generateId?: () => string;
+    /**
+     * File ID prefixes used to identify file IDs in Responses API.
+     * When undefined, all file data is treated as base64 content.
+     *
+     * Examples:
+     * - OpenAI: ['file-'] for IDs like 'file-abc123'
+     * - Azure OpenAI: ['assistant-'] for IDs like 'assistant-abc123'
+     */
+    fileIdPrefixes?: readonly string[];
+};

package/dist/types/github-copilot/responses/openai-error.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod/v4";
+export declare const openaiErrorDataSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        message: z.ZodString;
+        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        param: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+        code: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type OpenAIErrorData = z.infer<typeof openaiErrorDataSchema>;
+export declare const openaiFailedResponseHandler: import("@ai-sdk/provider-utils").ResponseHandler<import("@ai-sdk/provider").APICallError>;