@langchain/google-common 0.1.1 → 0.1.2

package/dist/connection.d.ts

@@ -1,7 +1,8 @@
 import { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
 import { AsyncCaller, AsyncCallerCallOptions } from "@langchain/core/utils/async_caller";
-import { StructuredToolParams } from "@langchain/core/tools";
-import type { GoogleAIBaseLLMInput, GoogleConnectionParams, GoogleLLMModelFamily, GooglePlatformType, GoogleResponse, GoogleLLMResponse, GeminiContent, GeminiGenerationConfig, GeminiRequest, GeminiSafetySetting, GeminiTool, GeminiFunctionDeclaration, GoogleAIModelRequestParams, GoogleRawResponse } from "./types.js";
+import { BaseRunManager } from "@langchain/core/callbacks/manager";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import type { GoogleAIBaseLLMInput, GoogleConnectionParams, GooglePlatformType, GoogleResponse, GoogleLLMResponse, GoogleAIModelRequestParams, GoogleRawResponse, GoogleAIAPI, VertexModelFamily, GoogleAIAPIConfig } from "./types.js";
 import { GoogleAbstractedClient, GoogleAbstractedClientOps, GoogleAbstractedClientOpsMethod } from "./auth.js";
 export declare abstract class GoogleConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleResponse> {
     caller: AsyncCaller;
@@ -22,12 +23,16 @@ export declare abstract class GoogleConnection<CallOptions extends AsyncCallerCa
 }
 export declare abstract class GoogleHostConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleResponse, AuthOptions> extends GoogleConnection<CallOptions, ResponseType> implements GoogleConnectionParams<AuthOptions> {
     platformType: GooglePlatformType | undefined;
-    endpoint: string;
-    location: string;
+    _endpoint: string | undefined;
+    _location: string | undefined;
     apiVersion: string;
     constructor(fields: GoogleConnectionParams<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming?: boolean);
     get platform(): GooglePlatformType;
     get computedPlatformType(): GooglePlatformType;
+    get location(): string;
+    get computedLocation(): string;
+    get endpoint(): string;
+    get computedEndpoint(): string;
     buildMethod(): GoogleAbstractedClientOpsMethod;
 }
 export declare abstract class GoogleRawConnection<CallOptions extends AsyncCallerCallOptions, AuthOptions> extends GoogleHostConnection<CallOptions, GoogleRawResponse, AuthOptions> {
@@ -37,27 +42,53 @@ export declare abstract class GoogleAIConnection<CallOptions extends AsyncCaller
     model: string;
     modelName: string;
     client: GoogleAbstractedClient;
-    api: any;
+    _apiName?: string;
+    apiConfig?: GoogleAIAPIConfig;
     constructor(fields: GoogleAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming?: boolean);
-    get modelFamily(): GoogleLLMModelFamily;
+    get modelFamily(): VertexModelFamily;
+    get modelPublisher(): string;
+    get computedAPIName(): string;
+    get apiName(): string;
+    get api(): GoogleAIAPI;
     get computedPlatformType(): GooglePlatformType;
+    get computedLocation(): string;
     abstract buildUrlMethod(): Promise<string>;
     buildUrlGenerativeLanguage(): Promise<string>;
     buildUrlVertex(): Promise<string>;
     buildUrl(): Promise<string>;
     abstract formatData(input: InputType, parameters: GoogleAIModelRequestParams): Promise<unknown>;
-    request(input: InputType, parameters: GoogleAIModelRequestParams, options: CallOptions): Promise<GoogleResponse>;
+    request(input: InputType, parameters: GoogleAIModelRequestParams, options: CallOptions, runManager?: BaseRunManager): Promise<ResponseType>;
 }
 export declare abstract class AbstractGoogleLLMConnection<MessageType, AuthOptions> extends GoogleAIConnection<BaseLanguageModelCallOptions, MessageType, AuthOptions, GoogleLLMResponse> {
     buildUrlMethodGemini(): Promise<string>;
+    buildUrlMethodClaude(): Promise<string>;
     buildUrlMethod(): Promise<string>;
-    abstract formatContents(input: MessageType, parameters: GoogleAIModelRequestParams): Promise<GeminiContent[]>;
-    formatGenerationConfig(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiGenerationConfig;
-    formatSafetySettings(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiSafetySetting[];
-    formatSystemInstruction(_input: MessageType, _parameters: GoogleAIModelRequestParams): Promise<GeminiContent>;
-    structuredToolToFunctionDeclaration(tool: StructuredToolParams): GeminiFunctionDeclaration;
-    structuredToolsToGeminiTools(tools: StructuredToolParams[]): GeminiTool[];
-    formatTools(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiTool[];
-    formatToolConfig(parameters: GoogleAIModelRequestParams): GeminiRequest["toolConfig"] | undefined;
-    formatData(input: MessageType, parameters: GoogleAIModelRequestParams): Promise<GeminiRequest>;
+    formatData(input: MessageType, parameters: GoogleAIModelRequestParams): Promise<unknown>;
+}
+export interface GoogleCustomEventInfo {
+    subEvent: string;
+    module: string;
+}
+export declare abstract class GoogleRequestCallbackHandler extends BaseCallbackHandler {
+    customEventInfo(eventName: string): GoogleCustomEventInfo;
+    abstract handleCustomRequestEvent(eventName: string, eventInfo: GoogleCustomEventInfo, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): any;
+    abstract handleCustomResponseEvent(eventName: string, eventInfo: GoogleCustomEventInfo, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): any;
+    abstract handleCustomChunkEvent(eventName: string, eventInfo: GoogleCustomEventInfo, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): any;
+    handleCustomEvent(eventName: string, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): any;
+}
+export declare class GoogleRequestLogger extends GoogleRequestCallbackHandler {
+    name: string;
+    log(eventName: string, data: any, tags?: string[]): undefined;
+    handleCustomRequestEvent(eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, tags?: string[], _metadata?: Record<string, any>): any;
+    handleCustomResponseEvent(eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, tags?: string[], _metadata?: Record<string, any>): any;
+    handleCustomChunkEvent(eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, tags?: string[], _metadata?: Record<string, any>): any;
+}
+export declare class GoogleRequestRecorder extends GoogleRequestCallbackHandler {
+    name: string;
+    request: any;
+    response: any;
+    chunk: any[];
+    handleCustomRequestEvent(_eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, _tags?: string[], _metadata?: Record<string, any>): any;
+    handleCustomResponseEvent(_eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, _tags?: string[], _metadata?: Record<string, any>): any;
+    handleCustomChunkEvent(_eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, _tags?: string[], _metadata?: Record<string, any>): any;
 }

package/dist/connection.js

@@ -1,7 +1,7 @@
 import { getRuntimeEnvironment } from "@langchain/core/utils/env";
-import { isLangChainTool } from "@langchain/core/utils/function_calling";
-import { zodToGeminiParameters } from "./utils/zod_to_gemini_parameters.js";
-import { getGeminiAPI } from "./utils/index.js";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { getGeminiAPI, modelToFamily, modelToPublisher, } from "./utils/index.js";
+import { getAnthropicAPI } from "./utils/anthropic.js";
 export class GoogleConnection {
     constructor(caller, client, streaming) {
         Object.defineProperty(this, "caller", {
@@ -98,17 +98,17 @@ export class GoogleHostConnection extends GoogleConnection {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "endpoint", {
+        Object.defineProperty(this, "_endpoint", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "us-central1-aiplatform.googleapis.com"
+            value: void 0
         });
-        Object.defineProperty(this, "location", {
+        Object.defineProperty(this, "_location", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "us-central1"
+            value: void 0
         });
         Object.defineProperty(this, "apiVersion", {
             enumerable: true,
@@ -118,8 +118,8 @@ export class GoogleHostConnection extends GoogleConnection {
         });
         this.caller = caller;
         this.platformType = fields?.platformType;
-        this.endpoint = fields?.endpoint ?? this.endpoint;
-        this.location = fields?.location ?? this.location;
+        this._endpoint = fields?.endpoint;
+        this._location = fields?.location;
         this.apiVersion = fields?.apiVersion ?? this.apiVersion;
         this.client = client;
     }
@@ -129,6 +129,18 @@ export class GoogleHostConnection extends GoogleConnection {
     get computedPlatformType() {
         return "gcp";
     }
+    get location() {
+        return this._location ?? this.computedLocation;
+    }
+    get computedLocation() {
+        return "us-central1";
+    }
+    get endpoint() {
+        return this._endpoint ?? this.computedEndpoint;
+    }
+    get computedEndpoint() {
+        return `${this.location}-aiplatform.googleapis.com`;
+    }
     buildMethod() {
         return "POST";
     }
@@ -161,24 +173,48 @@ export class GoogleAIConnection extends GoogleHostConnection {
             writable: true,
             value: void 0
         });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Object.defineProperty(this, "api", {
+        Object.defineProperty(this, "_apiName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "apiConfig", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
-        }); // FIXME: Make this a real type
+        });
         this.client = client;
         this.modelName = fields?.model ?? fields?.modelName ?? this.model;
         this.model = this.modelName;
-        this.api = getGeminiAPI(fields);
+        this._apiName = fields?.apiName;
+        this.apiConfig = {
+            safetyHandler: fields?.safetyHandler,
+            ...fields?.apiConfig,
+        };
     }
     get modelFamily() {
-        if (this.model.startsWith("gemini")) {
-            return "gemini";
-        }
-        else {
-            return null;
+        return modelToFamily(this.model);
+    }
+    get modelPublisher() {
+        return modelToPublisher(this.model);
+    }
+    get computedAPIName() {
+        // At least at the moment, model publishers and APIs map the same
+        return this.modelPublisher;
+    }
+    get apiName() {
+        return this._apiName ?? this.computedAPIName;
+    }
+    get api() {
+        switch (this.apiName) {
+            case "google":
+                return getGeminiAPI(this.apiConfig);
+            case "anthropic":
+                return getAnthropicAPI(this.apiConfig);
+            default:
+                throw new Error(`Unknown API: ${this.apiName}`);
         }
     }
     get computedPlatformType() {
@@ -189,6 +225,16 @@ export class GoogleAIConnection extends GoogleHostConnection {
             return "gcp";
         }
     }
+    get computedLocation() {
+        switch (this.apiName) {
+            case "google":
+                return super.computedLocation;
+            case "anthropic":
+                return "us-east5";
+            default:
+                throw new Error(`Unknown apiName: ${this.apiName}. Can't get location.`);
+        }
+    }
     async buildUrlGenerativeLanguage() {
         const method = await this.buildUrlMethod();
         const url = `https://generativelanguage.googleapis.com/${this.apiVersion}/models/${this.model}:${method}`;
@@ -197,7 +243,8 @@ export class GoogleAIConnection extends GoogleHostConnection {
     async buildUrlVertex() {
         const projectId = await this.client.getProjectId();
         const method = await this.buildUrlMethod();
-        const url = `https://${this.endpoint}/${this.apiVersion}/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:${method}`;
+        const publisher = this.modelPublisher;
+        const url = `https://${this.endpoint}/${this.apiVersion}/projects/${projectId}/locations/${this.location}/publishers/${publisher}/models/${this.model}:${method}`;
         return url;
     }
     async buildUrl() {
@@ -208,9 +255,30 @@ export class GoogleAIConnection extends GoogleHostConnection {
                 return this.buildUrlVertex();
         }
     }
-    async request(input, parameters, options) {
-        const data = await this.formatData(input, parameters);
+    async request(input, parameters, options, runManager) {
+        const moduleName = this.constructor.name;
+        const streamingParameters = {
+            ...parameters,
+            streaming: this.streaming,
+        };
+        const data = await this.formatData(input, streamingParameters);
+        await runManager?.handleCustomEvent(`google-request-${moduleName}`, {
+            data,
+            parameters: streamingParameters,
+            options,
+            connection: {
+                ...this,
+                url: await this.buildUrl(),
+                urlMethod: await this.buildUrlMethod(),
+                modelFamily: this.modelFamily,
+                modelPublisher: this.modelPublisher,
+                computedPlatformType: this.computedPlatformType,
+            },
+        });
         const response = await this._request(data, options);
+        await runManager?.handleCustomEvent(`google-response-${moduleName}`, {
+            response,
+        });
         return response;
     }
 }
@@ -218,98 +286,107 @@ export class AbstractGoogleLLMConnection extends GoogleAIConnection {
     async buildUrlMethodGemini() {
         return this.streaming ? "streamGenerateContent" : "generateContent";
     }
+    async buildUrlMethodClaude() {
+        return this.streaming ? "streamRawPredict" : "rawPredict";
+    }
     async buildUrlMethod() {
         switch (this.modelFamily) {
             case "gemini":
                 return this.buildUrlMethodGemini();
+            case "claude":
+                return this.buildUrlMethodClaude();
             default:
                 throw new Error(`Unknown model family: ${this.modelFamily}`);
         }
     }
-    formatGenerationConfig(_input, parameters) {
+    async formatData(input, parameters) {
+        return this.api.formatData(input, parameters);
+    }
+}
+export class GoogleRequestCallbackHandler extends BaseCallbackHandler {
+    customEventInfo(eventName) {
+        const names = eventName.split("-");
         return {
-            temperature: parameters.temperature,
-            topK: parameters.topK,
-            topP: parameters.topP,
-            maxOutputTokens: parameters.maxOutputTokens,
-            stopSequences: parameters.stopSequences,
-            responseMimeType: parameters.responseMimeType,
+            subEvent: names[1],
+            module: names[2],
         };
     }
-    formatSafetySettings(_input, parameters) {
-        return parameters.safetySettings ?? [];
+    handleCustomEvent(eventName, data, runId, tags, metadata) {
+        if (!eventName) {
+            return undefined;
+        }
+        const eventInfo = this.customEventInfo(eventName);
+        switch (eventInfo.subEvent) {
+            case "request":
+                return this.handleCustomRequestEvent(eventName, eventInfo, data, runId, tags, metadata);
+            case "response":
+                return this.handleCustomResponseEvent(eventName, eventInfo, data, runId, tags, metadata);
+            case "chunk":
+                return this.handleCustomChunkEvent(eventName, eventInfo, data, runId, tags, metadata);
+            default:
+                console.error(`Unexpected eventInfo for ${eventName} ${JSON.stringify(eventInfo, null, 1)}`);
+        }
     }
-    async formatSystemInstruction(_input, _parameters) {
-        return {};
+}
+export class GoogleRequestLogger extends GoogleRequestCallbackHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "GoogleRequestLogger"
+        });
     }
-    structuredToolToFunctionDeclaration(tool) {
-        const jsonSchema = zodToGeminiParameters(tool.schema);
-        return {
-            name: tool.name,
-            description: tool.description ?? `A function available to call.`,
-            parameters: jsonSchema,
-        };
+    log(eventName, data, tags) {
+        const tagStr = tags ? `[${tags}]` : "[]";
+        console.log(`${eventName} ${tagStr} ${JSON.stringify(data, null, 1)}`);
     }
-    structuredToolsToGeminiTools(tools) {
-        return [
-            {
-                functionDeclarations: tools.map(this.structuredToolToFunctionDeclaration),
-            },
-        ];
+    handleCustomRequestEvent(eventName, _eventInfo, data, _runId, tags, _metadata) {
+        this.log(eventName, data, tags);
     }
-    formatTools(_input, parameters) {
-        const tools = parameters?.tools;
-        if (!tools || tools.length === 0) {
-            return [];
-        }
-        if (tools.every(isLangChainTool)) {
-            return this.structuredToolsToGeminiTools(tools);
-        }
-        else {
-            if (tools.length === 1 &&
-                (!("functionDeclarations" in tools[0]) ||
-                    !tools[0].functionDeclarations?.length)) {
-                return [];
-            }
-            return tools;
-        }
+    handleCustomResponseEvent(eventName, _eventInfo, data, _runId, tags, _metadata) {
+        this.log(eventName, data, tags);
     }
-    formatToolConfig(parameters) {
-        if (!parameters.tool_choice || typeof parameters.tool_choice !== "string") {
-            return undefined;
-        }
-        return {
-            functionCallingConfig: {
-                mode: parameters.tool_choice,
-                allowedFunctionNames: parameters.allowed_function_names,
-            },
-        };
+    handleCustomChunkEvent(eventName, _eventInfo, data, _runId, tags, _metadata) {
+        this.log(eventName, data, tags);
     }
-    async formatData(input, parameters) {
-        const contents = await this.formatContents(input, parameters);
-        const generationConfig = this.formatGenerationConfig(input, parameters);
-        const tools = this.formatTools(input, parameters);
-        const toolConfig = this.formatToolConfig(parameters);
-        const safetySettings = this.formatSafetySettings(input, parameters);
-        const systemInstruction = await this.formatSystemInstruction(input, parameters);
-        const ret = {
-            contents,
-            generationConfig,
-        };
-        if (tools && tools.length) {
-            ret.tools = tools;
-        }
-        if (toolConfig) {
-            ret.toolConfig = toolConfig;
-        }
-        if (safetySettings && safetySettings.length) {
-            ret.safetySettings = safetySettings;
-        }
-        if (systemInstruction?.role &&
-            systemInstruction?.parts &&
-            systemInstruction?.parts?.length) {
-            ret.systemInstruction = systemInstruction;
-        }
-        return ret;
+}
+export class GoogleRequestRecorder extends GoogleRequestCallbackHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "GoogleRequestRecorder"
+        });
+        Object.defineProperty(this, "request", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "chunk", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    handleCustomRequestEvent(_eventName, _eventInfo, data, _runId, _tags, _metadata) {
+        this.request = data;
+    }
+    handleCustomResponseEvent(_eventName, _eventInfo, data, _runId, _tags, _metadata) {
+        this.response = data;
+    }
+    handleCustomChunkEvent(_eventName, _eventInfo, data, _runId, _tags, _metadata) {
+        this.chunk.push(data);
     }
 }

package/dist/llms.cjs

@@ -175,7 +175,7 @@ class GoogleBaseLLM extends llms_1.LLM {
     async _call(prompt, options) {
         const parameters = (0, common_js_1.copyAIModelParams)(this, options);
         const result = await this.connection.request(prompt, parameters, options);
-        const ret = this.connection.api.safeResponseToString(result, this.safetyHandler);
+        const ret = this.connection.api.responseToString(result);
         return ret;
     }
     // Normally, you should not override this method and instead should override
@@ -217,7 +217,7 @@ class GoogleBaseLLM extends llms_1.LLM {
     async predictMessages(messages, options, _callbacks) {
         const { content } = messages[0];
         const result = await this.connection.request(content, {}, options);
-        const ret = this.connection.api.safeResponseToBaseMessage(result, this.safetyHandler);
+        const ret = this.connection.api.responseToBaseMessage(result);
         return ret;
     }
     /**

package/dist/llms.js

@@ -172,7 +172,7 @@ export class GoogleBaseLLM extends LLM {
     async _call(prompt, options) {
         const parameters = copyAIModelParams(this, options);
         const result = await this.connection.request(prompt, parameters, options);
-        const ret = this.connection.api.safeResponseToString(result, this.safetyHandler);
+        const ret = this.connection.api.responseToString(result);
         return ret;
     }
     // Normally, you should not override this method and instead should override
@@ -214,7 +214,7 @@ export class GoogleBaseLLM extends LLM {
     async predictMessages(messages, options, _callbacks) {
         const { content } = messages[0];
         const result = await this.connection.request(content, {}, options);
-        const ret = this.connection.api.safeResponseToBaseMessage(result, this.safetyHandler);
+        const ret = this.connection.api.responseToBaseMessage(result);
         return ret;
     }
     /**

package/dist/types-anthropic.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types-anthropic.d.ts

@@ -0,0 +1,159 @@
+export interface AnthropicCacheControl {
+    type: "ephemeral" | string;
+}
+interface AnthropicMessageContentBase {
+    type: string;
+    cache_control?: AnthropicCacheControl | null;
+}
+export interface AnthropicMessageContentText extends AnthropicMessageContentBase {
+    type: "text";
+    text: string;
+}
+export interface AnthropicMessageContentImage extends AnthropicMessageContentBase {
+    type: "image";
+    source: {
+        type: "base64" | string;
+        media_type: string;
+        data: string;
+    };
+}
+export type AnthropicMessageContentToolUseInput = object;
+export interface AnthropicMessageContentToolUse extends AnthropicMessageContentBase {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: AnthropicMessageContentToolUseInput;
+}
+export type AnthropicMessageContentToolResultContent = AnthropicMessageContentText | AnthropicMessageContentImage;
+export interface AnthropicMessageContentToolResult extends AnthropicMessageContentBase {
+    type: "tool_result";
+    tool_use_id: string;
+    is_error?: boolean;
+    content: string | AnthropicMessageContentToolResultContent[];
+}
+export type AnthropicMessageContent = AnthropicMessageContentText | AnthropicMessageContentImage | AnthropicMessageContentToolUse | AnthropicMessageContentToolResult;
+export interface AnthropicMessage {
+    role: string;
+    content: string | AnthropicMessageContent[];
+}
+export interface AnthropicMetadata {
+    user_id?: string | null;
+}
+interface AnthropicToolChoiceBase {
+    type: string;
+}
+export interface AnthropicToolChoiceAuto extends AnthropicToolChoiceBase {
+    type: "auto";
+}
+export interface AnthropicToolChoiceAny extends AnthropicToolChoiceBase {
+    type: "any";
+}
+export interface AnthropicToolChoiceTool extends AnthropicToolChoiceBase {
+    type: "tool";
+    name: string;
+}
+export type AnthropicToolChoice = AnthropicToolChoiceAuto | AnthropicToolChoiceAny | AnthropicToolChoiceTool;
+export type AnthropicToolInputSchema = object;
+export interface AnthropicTool {
+    type?: string;
+    name: string;
+    description?: string;
+    cache_control?: AnthropicCacheControl;
+    input_schema: AnthropicToolInputSchema;
+}
+export interface AnthropicRequest {
+    anthropic_version: string;
+    messages: AnthropicMessage[];
+    system?: string;
+    stream?: boolean;
+    max_tokens: number;
+    temperature?: number;
+    top_k?: number;
+    top_p?: number;
+    stop_sequences?: string[];
+    metadata?: AnthropicMetadata;
+    tool_choice?: AnthropicToolChoice;
+    tools?: AnthropicTool[];
+}
+export type AnthropicRequestSettings = Pick<AnthropicRequest, "max_tokens" | "temperature" | "top_k" | "top_p" | "stop_sequences" | "stream">;
+export interface AnthropicContentText {
+    type: "text";
+    text: string;
+}
+export interface AnthropicContentToolUse {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: object;
+}
+export type AnthropicContent = AnthropicContentText | AnthropicContentToolUse;
+export interface AnthropicUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens: number | null;
+    cache_creation_output_tokens: number | null;
+}
+export type AnthropicResponseData = AnthropicResponseMessage | AnthropicStreamBaseEvent;
+export interface AnthropicResponseMessage {
+    id: string;
+    type: string;
+    role: string;
+    content: AnthropicContent[];
+    model: string;
+    stop_reason: string | null;
+    stop_sequence: string | null;
+    usage: AnthropicUsage;
+}
+export interface AnthropicAPIConfig {
+    version?: string;
+}
+export type AnthropicStreamEventType = "message_start" | "content_block_start" | "content_block_delta" | "content_block_stop" | "message_delta" | "message_stop" | "ping" | "error";
+export type AnthropicStreamDeltaType = "text_delta" | "input_json_delta";
+export interface AnthropicStreamBaseEvent {
+    type: AnthropicStreamEventType;
+}
+export interface AnthropicStreamMessageStartEvent extends AnthropicStreamBaseEvent {
+    type: "message_start";
+    message: AnthropicResponseMessage;
+}
+export interface AnthropicStreamContentBlockStartEvent extends AnthropicStreamBaseEvent {
+    type: "content_block_start";
+    index: number;
+    content_block: AnthropicContent;
+}
+export interface AnthropicStreamBaseDelta {
+    type: AnthropicStreamDeltaType;
+}
+export interface AnthropicStreamTextDelta extends AnthropicStreamBaseDelta {
+    type: "text_delta";
+    text: string;
+}
+export interface AnthropicStreamInputJsonDelta extends AnthropicStreamBaseDelta {
+    type: "input_json_delta";
+    partial_json: string;
+}
+export type AnthropicStreamDelta = AnthropicStreamTextDelta | AnthropicStreamInputJsonDelta;
+export interface AnthropicStreamContentBlockDeltaEvent extends AnthropicStreamBaseEvent {
+    type: "content_block_delta";
+    index: number;
+    delta: AnthropicStreamDelta;
+}
+export interface AnthropicStreamContentBlockStopEvent extends AnthropicStreamBaseEvent {
+    type: "content_block_stop";
+    index: number;
+}
+export interface AnthropicStreamMessageDeltaEvent extends AnthropicStreamBaseEvent {
+    type: "message_delta";
+    delta: Partial<AnthropicResponseMessage>;
+}
+export interface AnthropicStreamMessageStopEvent extends AnthropicStreamBaseEvent {
+    type: "message_stop";
+}
+export interface AnthropicStreamPingEvent extends AnthropicStreamBaseEvent {
+    type: "ping";
+}
+export interface AnthropicStreamErrorEvent extends AnthropicStreamBaseEvent {
+    type: "error";
+    error: any;
+}
+export {};

package/dist/types-anthropic.js

@@ -0,0 +1 @@
+export {};