@illuma-ai/agents 1.1.21 → 1.1.23

package/src/llm/bedrock/utils/message_outputs.js

@@ -1,269 +0,0 @@
-/**
- * Utility functions for converting Bedrock Converse responses to LangChain messages.
- * Ported from @langchain/aws common.js
- */
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
-/**
- * Convert a Bedrock reasoning block delta to a LangChain partial reasoning block.
- */
-export function bedrockReasoningDeltaToLangchainPartialReasoningBlock(reasoningContent) {
-    const { text, redactedContent, signature } = reasoningContent;
-    if (typeof text === 'string') {
-        return {
-            type: 'reasoning_content',
-            reasoningText: { text },
-        };
-    }
-    if (signature != null) {
-        return {
-            type: 'reasoning_content',
-            reasoningText: { signature },
-        };
-    }
-    if (redactedContent != null) {
-        return {
-            type: 'reasoning_content',
-            redactedContent: Buffer.from(redactedContent).toString('base64'),
-        };
-    }
-    throw new Error('Invalid reasoning content');
-}
-/**
- * Convert a Bedrock reasoning block to a LangChain reasoning block.
- */
-export function bedrockReasoningBlockToLangchainReasoningBlock(reasoningContent) {
-    const { reasoningText, redactedContent } = reasoningContent;
-    if (reasoningText != null) {
-        return {
-            type: 'reasoning_content',
-            reasoningText: reasoningText,
-        };
-    }
-    if (redactedContent != null) {
-        return {
-            type: 'reasoning_content',
-            redactedContent: Buffer.from(redactedContent).toString('base64'),
-        };
-    }
-    throw new Error('Invalid reasoning content');
-}
-/**
- * Convert a Bedrock Converse message to a LangChain message.
- */
-export function convertConverseMessageToLangChainMessage(message, responseMetadata) {
-    if (message.content == null) {
-        throw new Error('No message content found in response.');
-    }
-    if (message.role !== 'assistant') {
-        throw new Error(`Unsupported message role received in ChatBedrockConverse response: ${message.role}`);
-    }
-    let requestId;
-    if ('$metadata' in responseMetadata &&
-        responseMetadata.$metadata != null &&
-        typeof responseMetadata.$metadata === 'object' &&
-        'requestId' in responseMetadata.$metadata) {
-        requestId = responseMetadata.$metadata.requestId;
-    }
-    let tokenUsage;
-    if (responseMetadata.usage != null) {
-        const usage = responseMetadata.usage;
-        const input_tokens = usage.inputTokens ?? 0;
-        const output_tokens = usage.outputTokens ?? 0;
-        const cacheRead = usage.cacheReadInputTokens;
-        const cacheWrite = usage.cacheWriteInputTokens;
-        tokenUsage = {
-            input_tokens,
-            output_tokens,
-            total_tokens: usage.totalTokens ?? input_tokens + output_tokens,
-        };
-        if (cacheRead != null || cacheWrite != null) {
-            tokenUsage.input_token_details = {
-                cache_read: cacheRead ?? 0,
-                cache_creation: cacheWrite ?? 0,
-            };
-        }
-    }
-    if (message.content.length === 1 &&
-        'text' in message.content[0] &&
-        typeof message.content[0].text === 'string') {
-        return new AIMessage({
-            content: message.content[0].text,
-            response_metadata: responseMetadata,
-            usage_metadata: tokenUsage,
-            id: requestId,
-        });
-    }
-    else {
-        const toolCalls = [];
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const content = [];
-        message.content.forEach((c) => {
-            if ('toolUse' in c &&
-                c.toolUse != null &&
-                c.toolUse.name != null &&
-                c.toolUse.name !== '' &&
-                c.toolUse.input != null &&
-                typeof c.toolUse.input === 'object') {
-                toolCalls.push({
-                    id: c.toolUse.toolUseId,
-                    name: c.toolUse.name,
-                    args: c.toolUse.input,
-                    type: 'tool_call',
-                });
-            }
-            else if ('text' in c && typeof c.text === 'string') {
-                content.push({ type: 'text', text: c.text });
-            }
-            else if ('reasoningContent' in c && c.reasoningContent != null) {
-                content.push(bedrockReasoningBlockToLangchainReasoningBlock(c.reasoningContent));
-            }
-            else {
-                content.push(c);
-            }
-        });
-        return new AIMessage({
-            content: content.length ? content : '',
-            tool_calls: toolCalls.length ? toolCalls : undefined,
-            response_metadata: responseMetadata,
-            usage_metadata: tokenUsage,
-            id: requestId,
-        });
-    }
-}
-/**
- * Handle a content block delta event from Bedrock Converse stream.
- */
-export function handleConverseStreamContentBlockDelta(contentBlockDelta) {
-    if (contentBlockDelta.delta == null) {
-        throw new Error('No delta found in content block.');
-    }
-    if (typeof contentBlockDelta.delta.text === 'string') {
-        return new ChatGenerationChunk({
-            text: contentBlockDelta.delta.text,
-            message: new AIMessageChunk({
-                content: contentBlockDelta.delta.text,
-                response_metadata: {
-                    contentBlockIndex: contentBlockDelta.contentBlockIndex,
-                },
-            }),
-        });
-    }
-    else if (contentBlockDelta.delta.toolUse != null) {
-        const index = contentBlockDelta.contentBlockIndex;
-        return new ChatGenerationChunk({
-            text: '',
-            message: new AIMessageChunk({
-                content: '',
-                tool_call_chunks: [
-                    {
-                        args: contentBlockDelta.delta.toolUse.input,
-                        index,
-                        type: 'tool_call_chunk',
-                    },
-                ],
-                response_metadata: {
-                    contentBlockIndex: contentBlockDelta.contentBlockIndex,
-                },
-            }),
-        });
-    }
-    else if (contentBlockDelta.delta.reasoningContent != null) {
-        const reasoningBlock = bedrockReasoningDeltaToLangchainPartialReasoningBlock(contentBlockDelta.delta.reasoningContent);
-        let reasoningText = '';
-        if ('reasoningText' in reasoningBlock) {
-            reasoningText = reasoningBlock.reasoningText.text ?? '';
-        }
-        else if ('redactedContent' in reasoningBlock) {
-            reasoningText = reasoningBlock.redactedContent;
-        }
-        return new ChatGenerationChunk({
-            text: '',
-            message: new AIMessageChunk({
-                content: [reasoningBlock],
-                additional_kwargs: {
-                    // Set reasoning_content for stream handler to detect reasoning mode
-                    reasoning_content: reasoningText,
-                },
-                response_metadata: {
-                    contentBlockIndex: contentBlockDelta.contentBlockIndex,
-                },
-            }),
-        });
-    }
-    else {
-        // Silent healing: unknown content block types are logged and skipped
-        console.warn(`[Bedrock:SilentHeal] Unknown content block delta type — skipping: ${JSON.stringify(contentBlockDelta.delta, null, 2)}`);
-        return new ChatGenerationChunk({
-            text: '',
-            message: new AIMessageChunk({
-                content: '',
-                response_metadata: {
-                    contentBlockIndex: contentBlockDelta.contentBlockIndex,
-                },
-            }),
-        });
-    }
-}
-/**
- * Handle a content block start event from Bedrock Converse stream.
- */
-export function handleConverseStreamContentBlockStart(contentBlockStart) {
-    const index = contentBlockStart.contentBlockIndex;
-    if (contentBlockStart.start?.toolUse != null) {
-        return new ChatGenerationChunk({
-            text: '',
-            message: new AIMessageChunk({
-                content: '',
-                tool_call_chunks: [
-                    {
-                        name: contentBlockStart.start.toolUse.name,
-                        id: contentBlockStart.start.toolUse.toolUseId,
-                        index,
-                        type: 'tool_call_chunk',
-                    },
-                ],
-                response_metadata: {
-                    contentBlockIndex: index,
-                },
-            }),
-        });
-    }
-    // Return null for non-tool content block starts (text blocks don't need special handling)
-    return null;
-}
-/**
- * Handle a metadata event from Bedrock Converse stream.
- */
-export function handleConverseStreamMetadata(metadata, extra) {
-    const usage = metadata.usage;
-    const inputTokens = usage?.inputTokens ?? 0;
-    const outputTokens = usage?.outputTokens ?? 0;
-    const cacheRead = usage?.cacheReadInputTokens;
-    const cacheWrite = usage?.cacheWriteInputTokens;
-    const usage_metadata = {
-        input_tokens: inputTokens,
-        output_tokens: outputTokens,
-        total_tokens: usage?.totalTokens ?? inputTokens + outputTokens,
-    };
-    if (cacheRead != null || cacheWrite != null) {
-        usage_metadata.input_token_details = {
-            cache_read: cacheRead ?? 0,
-            cache_creation: cacheWrite ?? 0,
-        };
-    }
-    return new ChatGenerationChunk({
-        text: '',
-        message: new AIMessageChunk({
-            content: '',
-            usage_metadata: extra.streamUsage
-                ? usage_metadata
-                : undefined,
-            response_metadata: {
-                // Use the same key as returned from the Converse API
-                metadata,
-            },
-        }),
-    });
-}
-//# sourceMappingURL=message_outputs.js.map

package/src/llm/fake.js

@@ -1,92 +0,0 @@
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { AIMessageChunk } from '@langchain/core/messages';
-import { FakeListChatModel } from '@langchain/core/utils/testing';
-export class FakeChatModel extends FakeListChatModel {
-    splitStrategy;
-    toolCalls = [];
-    addedToolCalls = false;
-    constructor({ responses, sleep, emitCustomEvent, splitStrategy = { type: 'regex', value: /(?<=\s+)|(?=\s+)/ }, toolCalls = [] }) {
-        super({ responses, sleep, emitCustomEvent });
-        this.splitStrategy = splitStrategy;
-        this.toolCalls = toolCalls;
-    }
-    splitText(text) {
-        if (this.splitStrategy.type === 'regex') {
-            return text.split(this.splitStrategy.value);
-        }
-        else {
-            const chunkSize = this.splitStrategy.value;
-            const chunks = [];
-            for (let i = 0; i < text.length; i += chunkSize) {
-                chunks.push(text.slice(i, i + chunkSize));
-            }
-            return chunks;
-        }
-    }
-    _createResponseChunk(text, tool_call_chunks) {
-        return new ChatGenerationChunk({
-            text,
-            generationInfo: {},
-            message: new AIMessageChunk({
-                content: text,
-                tool_call_chunks,
-                additional_kwargs: tool_call_chunks ? {
-                    tool_calls: tool_call_chunks.map((toolCall) => ({
-                        index: toolCall.index ?? 0,
-                        id: toolCall.id ?? '',
-                        type: 'function',
-                        function: {
-                            name: toolCall.name ?? '',
-                            arguments: toolCall.args ?? '',
-                        },
-                    })),
-                } : undefined,
-            })
-        });
-    }
-    async *_streamResponseChunks(_messages, options, runManager) {
-        const response = this._currentResponse();
-        this._incrementResponse();
-        if (this.emitCustomEvent) {
-            await runManager?.handleCustomEvent('some_test_event', {
-                someval: true,
-            });
-        }
-        const chunks = this.splitText(response);
-        for await (const chunk of chunks) {
-            await this._sleepIfRequested();
-            if (options.thrownErrorString != null && options.thrownErrorString) {
-                throw new Error(options.thrownErrorString);
-            }
-            const responseChunk = super._createResponseChunk(chunk);
-            yield responseChunk;
-            void runManager?.handleLLMNewToken(chunk);
-        }
-        await this._sleepIfRequested();
-        if (this.toolCalls.length > 0 && !this.addedToolCalls) {
-            this.addedToolCalls = true;
-            const toolCallChunks = this.toolCalls.map((toolCall) => {
-                ;
-                return {
-                    name: toolCall.name,
-                    args: JSON.stringify(toolCall.args),
-                    id: toolCall.id,
-                    type: 'tool_call_chunk',
-                };
-            });
-            const responseChunk = this._createResponseChunk('', toolCallChunks);
-            yield responseChunk;
-            void runManager?.handleLLMNewToken('');
-        }
-    }
-}
-export function createFakeStreamingLLM({ responses, sleep, splitStrategy, toolCalls, }) {
-    return new FakeChatModel({
-        sleep,
-        responses,
-        emitCustomEvent: true,
-        splitStrategy,
-        toolCalls,
-    });
-}
-//# sourceMappingURL=fake.js.map

package/src/llm/google/index.js

@@ -1,215 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
-import { getEnvironmentVariable } from '@langchain/core/utils/env';
-import { GoogleGenerativeAI as GenerativeAI } from '@google/generative-ai';
-import { convertResponseContentToChatGenerationChunk, convertBaseMessagesToContent, mapGenerateContentResultToChatResult, } from './utils/common';
-export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
-    thinkingConfig;
-    /**
-     * Override to add gemini-3 model support for multimodal and function calling thought signatures
-     */
-    get _isMultimodalModel() {
-        return (this.model.startsWith('gemini-1.5') ||
-            this.model.startsWith('gemini-2') ||
-            (this.model.startsWith('gemma-3-') &&
-                !this.model.startsWith('gemma-3-1b')) ||
-            this.model.startsWith('gemini-3'));
-    }
-    constructor(fields) {
-        super(fields);
-        this.model = fields.model.replace(/^models\//, '');
-        this.maxOutputTokens = fields.maxOutputTokens ?? this.maxOutputTokens;
-        if (this.maxOutputTokens != null && this.maxOutputTokens < 0) {
-            throw new Error('`maxOutputTokens` must be a positive integer');
-        }
-        this.temperature = fields.temperature ?? this.temperature;
-        if (this.temperature != null &&
-            (this.temperature < 0 || this.temperature > 2)) {
-            throw new Error('`temperature` must be in the range of [0.0,2.0]');
-        }
-        this.topP = fields.topP ?? this.topP;
-        if (this.topP != null && this.topP < 0) {
-            throw new Error('`topP` must be a positive integer');
-        }
-        if (this.topP != null && this.topP > 1) {
-            throw new Error('`topP` must be below 1.');
-        }
-        this.topK = fields.topK ?? this.topK;
-        if (this.topK != null && this.topK < 0) {
-            throw new Error('`topK` must be a positive integer');
-        }
-        this.stopSequences = fields.stopSequences ?? this.stopSequences;
-        this.apiKey = fields.apiKey ?? getEnvironmentVariable('GOOGLE_API_KEY');
-        if (this.apiKey == null || this.apiKey === '') {
-            throw new Error('Please set an API key for Google GenerativeAI ' +
-                'in the environment variable GOOGLE_API_KEY ' +
-                'or in the `apiKey` field of the ' +
-                'ChatGoogleGenerativeAI constructor');
-        }
-        this.safetySettings = fields.safetySettings ?? this.safetySettings;
-        if (this.safetySettings && this.safetySettings.length > 0) {
-            const safetySettingsSet = new Set(this.safetySettings.map((s) => s.category));
-            if (safetySettingsSet.size !== this.safetySettings.length) {
-                throw new Error('The categories in `safetySettings` array must be unique');
-            }
-        }
-        this.thinkingConfig = fields.thinkingConfig ?? this.thinkingConfig;
-        this.streaming = fields.streaming ?? this.streaming;
-        this.json = fields.json;
-        // @ts-ignore - Accessing private property from parent class
-        this.client = new GenerativeAI(this.apiKey).getGenerativeModel({
-            model: this.model,
-            safetySettings: this.safetySettings,
-            generationConfig: {
-                stopSequences: this.stopSequences,
-                maxOutputTokens: this.maxOutputTokens,
-                temperature: this.temperature,
-                topP: this.topP,
-                topK: this.topK,
-                ...(this.json != null
-                    ? { responseMimeType: 'application/json' }
-                    : {}),
-            },
-        }, {
-            apiVersion: fields.apiVersion,
-            baseUrl: fields.baseUrl,
-            customHeaders: fields.customHeaders,
-        });
-        this.streamUsage = fields.streamUsage ?? this.streamUsage;
-    }
-    static lc_name() {
-        return 'IllumaGoogleGenerativeAI';
-    }
-    /**
-     * Helper function to convert Gemini API usage metadata to LangChain format
-     * Includes support for cached tokens and tier-based tracking for gemini-3-pro-preview
-     */
-    _convertToUsageMetadata(usageMetadata, model) {
-        if (!usageMetadata) {
-            return undefined;
-        }
-        const output = {
-            input_tokens: usageMetadata.promptTokenCount ?? 0,
-            output_tokens: (usageMetadata.candidatesTokenCount ?? 0) +
-                (usageMetadata.thoughtsTokenCount ?? 0),
-            total_tokens: usageMetadata.totalTokenCount ?? 0,
-        };
-        if (usageMetadata.cachedContentTokenCount) {
-            output.input_token_details ??= {};
-            output.input_token_details.cache_read =
-                usageMetadata.cachedContentTokenCount;
-        }
-        // gemini-3-pro-preview has bracket based tracking of tokens per request
-        if (model === 'gemini-3-pro-preview') {
-            const over200k = Math.max(0, (usageMetadata.promptTokenCount ?? 0) - 200000);
-            const cachedOver200k = Math.max(0, (usageMetadata.cachedContentTokenCount ?? 0) - 200000);
-            if (over200k) {
-                output.input_token_details = {
-                    ...output.input_token_details,
-                    over_200k: over200k,
-                };
-            }
-            if (cachedOver200k) {
-                output.input_token_details = {
-                    ...output.input_token_details,
-                    cache_read_over_200k: cachedOver200k,
-                };
-            }
-        }
-        return output;
-    }
-    invocationParams(options) {
-        const params = super.invocationParams(options);
-        if (this.thinkingConfig) {
-            /** @ts-ignore */
-            this.client.generationConfig = {
-                /** @ts-ignore */
-                ...this.client.generationConfig,
-                /** @ts-ignore */
-                thinkingConfig: this.thinkingConfig,
-            };
-        }
-        return params;
-    }
-    async _generate(messages, options, runManager) {
-        const prompt = convertBaseMessagesToContent(messages, this._isMultimodalModel, this.useSystemInstruction, this.model);
-        let actualPrompt = prompt;
-        if (prompt?.[0].role === 'system') {
-            const [systemInstruction] = prompt;
-            /** @ts-ignore */
-            this.client.systemInstruction = systemInstruction;
-            actualPrompt = prompt.slice(1);
-        }
-        const parameters = this.invocationParams(options);
-        const request = {
-            ...parameters,
-            contents: actualPrompt,
-        };
-        const res = await this.caller.callWithOptions({ signal: options.signal }, async () => 
-        /** @ts-ignore */
-        this.client.generateContent(request));
-        const response = res.response;
-        const usageMetadata = this._convertToUsageMetadata(
-        /** @ts-ignore */
-        response.usageMetadata, this.model);
-        /** @ts-ignore */
-        const generationResult = mapGenerateContentResultToChatResult(response, {
-            usageMetadata,
-        });
-        await runManager?.handleLLMNewToken(generationResult.generations[0].text || '', undefined, undefined, undefined, undefined, undefined);
-        return generationResult;
-    }
-    async *_streamResponseChunks(messages, options, runManager) {
-        const prompt = convertBaseMessagesToContent(messages, this._isMultimodalModel, this.useSystemInstruction, this.model);
-        let actualPrompt = prompt;
-        if (prompt?.[0].role === 'system') {
-            const [systemInstruction] = prompt;
-            /** @ts-ignore */
-            this.client.systemInstruction = systemInstruction;
-            actualPrompt = prompt.slice(1);
-        }
-        const parameters = this.invocationParams(options);
-        const request = {
-            ...parameters,
-            contents: actualPrompt,
-        };
-        const stream = await this.caller.callWithOptions({ signal: options.signal }, async () => {
-            /** @ts-ignore */
-            const { stream } = await this.client.generateContentStream(request);
-            return stream;
-        });
-        let index = 0;
-        let lastUsageMetadata;
-        for await (const response of stream) {
-            if ('usageMetadata' in response &&
-                this.streamUsage !== false &&
-                options.streamUsage !== false) {
-                lastUsageMetadata = this._convertToUsageMetadata(response.usageMetadata, this.model);
-            }
-            const chunk = convertResponseContentToChatGenerationChunk(response, {
-                usageMetadata: undefined,
-                index,
-            });
-            index += 1;
-            if (!chunk) {
-                continue;
-            }
-            yield chunk;
-            await runManager?.handleLLMNewToken(chunk.text || '', undefined, undefined, undefined, undefined, { chunk });
-        }
-        if (lastUsageMetadata) {
-            const finalChunk = new ChatGenerationChunk({
-                text: '',
-                message: new AIMessageChunk({
-                    content: '',
-                    usage_metadata: lastUsageMetadata,
-                }),
-            });
-            yield finalChunk;
-            await runManager?.handleLLMNewToken(finalChunk.text || '', undefined, undefined, undefined, undefined, { chunk: finalChunk });
-        }
-    }
-}
-//# sourceMappingURL=index.js.map

package/src/llm/google/types.js

@@ -1,12 +0,0 @@
-/** Enum for content modality types */
-var Modality;
-(function (Modality) {
-    Modality["MODALITY_UNSPECIFIED"] = "MODALITY_UNSPECIFIED";
-    Modality["TEXT"] = "TEXT";
-    Modality["IMAGE"] = "IMAGE";
-    Modality["VIDEO"] = "VIDEO";
-    Modality["AUDIO"] = "AUDIO";
-    Modality["DOCUMENT"] = "DOCUMENT";
-})(Modality || (Modality = {}));
-export {};
-//# sourceMappingURL=types.js.map