opencontrol/dist/types/index.d.ts

import { Hono } from "hono";
import { Tool } from "./tool.js";
import { LanguageModelV1, LanguageModelV1CallOptions } from "ai";
export interface OpenControlOptions {
    tools: Tool[];
    password?: string;
    model?: LanguageModelV1;
    app?: Hono;
}
export type App = ReturnType<typeof create>;
export declare function create(input: OpenControlOptions): import("hono/hono-base").HonoBase<{}, {
    "/": {
        $get: {
            input: {};
            output: {};
            outputFormat: string;
            status: import("hono/utils/http-status").StatusCode;
        };
    };
} & {
    "/auth": {
        $get: {
            input: {};
            output: {};
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
        };
    };
} & {
    "/generate": {
        $post: {
            input: {
                json: LanguageModelV1CallOptions;
            };
            output: {
                text?: string | undefined;
                reasoning?: string | ({
                    type: "text";
                    text: string;
                    signature?: string | undefined;
                } | {
                    type: "redacted";
                    data: string;
                })[] | undefined;
                files?: {
                    data: string | {
                        [x: number]: number;
                        readonly BYTES_PER_ELEMENT: number;
                        readonly buffer: {
                            readonly byteLength: number;
                            slice: {};
                        } | {
                            readonly byteLength: number;
                            slice: {};
                        };
                        readonly byteLength: number;
                        readonly byteOffset: number;
                        copyWithin: {};
                        every: {};
                        fill: {};
                        filter: {};
                        find: {};
                        findIndex: {};
                        forEach: {};
                        indexOf: {};
                        join: {};
                        lastIndexOf: {};
                        readonly length: number;
                        map: {};
                        reduce: {};
                        reduceRight: {};
                        set: {};
                        slice: {};
                        some: {};
                        sort: {};
                        subarray: {};
                        includes: {};
                        at: {};
                        findLast: {};
                        findLastIndex: {};
                        toSorted: {};
                        with: {};
                    };
                    mimeType: string;
                }[] | undefined;
                toolCalls?: {
                    toolCallType: "function";
                    toolCallId: string;
                    toolName: string;
                    args: string;
                }[] | undefined;
                finishReason: import("@ai-sdk/provider").LanguageModelV1FinishReason;
                usage: {
                    promptTokens: number;
                    completionTokens: number;
                };
                rawCall: {
                    rawPrompt: never;
                    rawSettings: {
                        [x: string]: never;
                    };
                };
                rawResponse?: {
                    headers?: {
                        [x: string]: string;
                    } | undefined;
                    body?: undefined;
                } | undefined;
                request?: {
                    body?: string | undefined;
                } | undefined;
                response?: {
                    id?: string | undefined;
                    timestamp?: string | undefined;
                    modelId?: string | undefined;
                } | undefined;
                warnings?: ({
                    type: "unsupported-setting";
                    setting: keyof {
                        maxTokens?: number;
                        temperature?: number;
                        stopSequences?: string[];
                        topP?: number;
                        topK?: number;
                        presencePenalty?: number;
                        frequencyPenalty?: number;
                        responseFormat?: {
                            type: "text";
                        } | {
                            type: "json";
                            schema?: JSONSchema7;
                            name?: string;
                            description?: string;
                        };
                        seed?: number;
                        abortSignal?: AbortSignal;
                        headers?: Record<string, string | undefined>;
                    };
                    details?: string | undefined;
                } | {
                    type: "unsupported-tool";
                    tool: {
                        type: "function";
                        name: string;
                        description?: string | undefined;
                        parameters: JSONSchema7;
                    } | {
                        type: "provider-defined";
                        id: `${string}.${string}`;
                        name: string;
                        args: {
                            [x: string]: never;
                        };
                    };
                    details?: string | undefined;
                } | {
                    type: "other";
                    message: string;
                })[] | undefined;
                providerMetadata?: {
                    [x: string]: {
                        [x: string]: any;
                    };
                } | undefined;
                sources?: {
                    sourceType: "url";
                    id: string;
                    url: string;
                    title?: string | undefined;
                    providerMetadata?: {
                        [x: string]: {
                            [x: string]: any;
                        };
                    } | undefined;
                }[] | undefined;
                logprobs?: {
                    token: string;
                    logprob: number;
                    topLogprobs: {
                        token: string;
                        logprob: number;
                    }[];
                }[] | undefined;
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
        };
    };
} & {
    "/mcp": {
        $post: {
            input: {};
            output: {
                jsonrpc: "2.0";
                id: string | number;
                result: {
                    content: {
                        type: "text";
                        text: string;
                    }[];
                } | {
                    protocolVersion: string;
                    capabilities: {
                        tools: {};
                    };
                    serverInfo: {
                        name: string;
                        version: string;
                    };
                } | {
                    tools: {
                        name: string;
                        inputSchema: any;
                        description: string;
                    }[];
                } | {
                    isError: true;
                    content: {
                        type: "text";
                        text: string;
                    }[];
                };
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
        };
    };
}, "/">;
//# sourceMappingURL=index.d.ts.map