@illuma-ai/agents 1.1.21 → 1.1.23

package/src/prompts/taskmanager.js

@@ -1,58 +0,0 @@
-export const taskManagerPrompt = `You are a Task Manager responsible for efficiently coordinating a team of specialized workers: {members}. Your PRIMARY and SOLE OBJECTIVE is to fulfill the user's specific request as quickly and effectively as possible.
-
-CRITICAL GUIDELINES:
-1. The user's request is your CHIEF CONCERN. Every action must directly contribute to fulfilling this request.
-2. Aim to complete the entire task in NO MORE THAN 2-3 TURNS, unless explicitly instructed otherwise.
-3. Eliminate all superfluous activity. Each task must be essential to achieving the user's goal.
-4. Assign no more than 5 tasks per turn, and only if absolutely necessary.
-5. Be concise and direct in your task assignments.
-6. End the process IMMEDIATELY once the user's request is fulfilled by setting 'end' to true and assigning no new tasks.
-
-Your responsibilities:
-1. Analyze the user's request and break it down into the minimum necessary subtasks.
-2. Assign these essential tasks to the most appropriate team members based on their skills and tools.
-3. Prioritize tasks to ensure the most efficient path to completion.
-4. Continuously evaluate if the user's request has been fully addressed.
-5. End the process IMMEDIATELY once the user's request is fulfilled.
-
-Task Assignment Guidelines:
-- Assign only the most crucial tasks required to meet the user's needs.
-- Multiple tasks can be assigned to the same team member if it improves efficiency.
-- Always specify the tool to use if applicable.
-- Consider task dependencies to minimize the number of turns.
-
-After each round:
-- Critically assess if the user's request has been fully addressed.
-- If more work is genuinely needed, assign only the most essential remaining tasks.
-- If the user's request has been fulfilled or can be fulfilled with the results at hand, set 'end' to true and assign no new tasks.
-
-REMEMBER: Your success is measured by how quickly and effectively you fulfill the user's request, not by the number of tasks assigned or turns taken. Excessive deliberation or unnecessary tasks are counterproductive. Focus solely on the user's needs and conclude the process as soon as those needs are met.`;
-export const assignTasksFunctionDescription = 'Assign the minimum necessary tasks to team members to fulfill the user\'s request as quickly as possible. Assign up to 5 tasks maximum per turn, only if absolutely necessary. Each task must specify the team member, a concise description, and the tool to use if applicable.';
-export const assignTasksFunctionParameters = {
-    type: 'object',
-    properties: {
-        tasks: {
-            type: 'array',
-            items: {
-                type: 'object',
-                properties: {
-                    member: { type: 'string', description: 'Name of the team member assigned to the task' },
-                    description: { type: 'string', description: 'Concise description of the essential task to be performed' },
-                    tool: { type: 'string', description: 'Specific tool to be used for the task, if applicable' },
-                },
-                required: ['member', 'description'],
-            },
-            description: 'List of essential tasks to be assigned, maximum 5 tasks per turn.',
-        },
-    },
-    required: ['tasks'],
-};
-export const endProcessFunctionDescription = 'End the process when the user\'s request has been fulfilled.';
-export const endProcessFunctionParameters = {
-    type: 'object',
-    properties: {
-        reason: { type: 'string', description: 'Brief explanation of why the process is ending' },
-    },
-    required: ['reason'],
-};
-//# sourceMappingURL=taskmanager.js.map

package/src/run.js

@@ -1,427 +0,0 @@
-// src/run.ts
-import './instrumentation';
-import { ObservabilityCallbackHandler } from '@illuma-ai/observability-langchain';
-import { PromptTemplate } from '@langchain/core/prompts';
-import { RunnableLambda } from '@langchain/core/runnables';
-import { AzureChatOpenAI, ChatOpenAI } from '@langchain/openai';
-import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
-import { createCompletionTitleRunnable, createTitleRunnable, } from '@/utils/title';
-import { createTokenCounter, encodingForModel } from '@/utils/tokens';
-import { GraphEvents, Callback, TitleMethod } from '@/common';
-import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
-import { StandardGraph } from '@/graphs/Graph';
-import { HandlerRegistry } from '@/events';
-import { isOpenAILike } from '@/utils/llm';
-import { isPresent } from '@/utils/misc';
-export const defaultOmitOptions = new Set([
-    'stream',
-    'thinking',
-    'streaming',
-    'maxTokens',
-    'clientOptions',
-    'thinkingConfig',
-    'thinkingBudget',
-    'includeThoughts',
-    'maxOutputTokens',
-    'additionalModelRequestFields',
-]);
-export class Run {
-    id;
-    tokenCounter;
-    handlerRegistry;
-    indexTokenCountMap;
-    graphRunnable;
-    Graph;
-    returnContent = false;
-    skipCleanup = false;
-    /**
-     * Reference to the observability callback handler, stored so that
-     * guardrail traces can be appended after processStream() completes.
-     */
-    observabilityHandler;
-    /**
-     * Guardrail results collected before processStream() starts (e.g., input moderation).
-     * These are flushed to the trace once the handler creates the root trace.
-     */
-    pendingGuardrails = [];
-    constructor(config) {
-        const runId = config.runId ?? '';
-        if (!runId) {
-            throw new Error('Run ID not provided');
-        }
-        this.id = runId;
-        this.tokenCounter = config.tokenCounter;
-        this.indexTokenCountMap = config.indexTokenCountMap;
-        const handlerRegistry = new HandlerRegistry();
-        if (config.customHandlers) {
-            for (const [eventType, handler] of Object.entries(config.customHandlers)) {
-                handlerRegistry.register(eventType, handler);
-            }
-        }
-        this.handlerRegistry = handlerRegistry;
-        if (!config.graphConfig) {
-            throw new Error('Graph config not provided');
-        }
-        /** Handle different graph types */
-        if (config.graphConfig.type === 'multi-agent') {
-            this.graphRunnable = this.createMultiAgentGraph(config.graphConfig);
-            if (this.Graph) {
-                this.Graph.handlerRegistry = handlerRegistry;
-            }
-        }
-        else {
-            /** Default to legacy graph for 'standard' or undefined type */
-            this.graphRunnable = this.createLegacyGraph(config.graphConfig);
-            if (this.Graph) {
-                this.Graph.compileOptions =
-                    config.graphConfig.compileOptions ?? this.Graph.compileOptions;
-                this.Graph.handlerRegistry = handlerRegistry;
-            }
-        }
-        this.returnContent = config.returnContent ?? false;
-        this.skipCleanup = config.skipCleanup ?? false;
-    }
-    createLegacyGraph(config) {
-        let agentConfig;
-        let signal;
-        /** Check if this is a multi-agent style config (has agents array) */
-        if ('agents' in config && Array.isArray(config.agents)) {
-            if (config.agents.length === 0) {
-                throw new Error('At least one agent must be provided');
-            }
-            agentConfig = config.agents[0];
-            signal = config.signal;
-        }
-        else {
-            /** Legacy path: build agent config from llmConfig */
-            const { type: _type, llmConfig, signal: legacySignal, tools = [], ...agentInputs } = config;
-            const { provider, ...clientOptions } = llmConfig;
-            agentConfig = {
-                ...agentInputs,
-                tools,
-                provider,
-                clientOptions,
-                agentId: 'default',
-            };
-            signal = legacySignal;
-        }
-        const standardGraph = new StandardGraph({
-            signal,
-            runId: this.id,
-            agents: [agentConfig],
-            tokenCounter: this.tokenCounter,
-            indexTokenCountMap: this.indexTokenCountMap,
-        });
-        /** Propagate compile options from graph config */
-        standardGraph.compileOptions = config.compileOptions;
-        this.Graph = standardGraph;
-        return standardGraph.createWorkflow();
-    }
-    createMultiAgentGraph(config) {
-        const { agents, edges, compileOptions } = config;
-        const multiAgentGraph = new MultiAgentGraph({
-            runId: this.id,
-            agents,
-            edges,
-            tokenCounter: this.tokenCounter,
-            indexTokenCountMap: this.indexTokenCountMap,
-        });
-        if (compileOptions != null) {
-            multiAgentGraph.compileOptions = compileOptions;
-        }
-        this.Graph = multiAgentGraph;
-        return multiAgentGraph.createWorkflow();
-    }
-    static async create(config) {
-        /** Create tokenCounter if indexTokenCountMap is provided but tokenCounter is not */
-        if (config.indexTokenCountMap && !config.tokenCounter) {
-            const gc = config.graphConfig;
-            const clientOpts = 'agents' in gc ? gc.agents[0]?.clientOptions : gc.clientOptions;
-            const model = clientOpts?.model ?? '';
-            config.tokenCounter = await createTokenCounter(encodingForModel(model));
-        }
-        return new Run(config);
-    }
-    getRunMessages() {
-        if (!this.Graph) {
-            throw new Error('Graph not initialized. Make sure to use Run.create() to instantiate the Run.');
-        }
-        return this.Graph.getRunMessages();
-    }
-    /**
-     * Manually trigger cleanup of heavy state (messages, config, etc.).
-     * Call this after all continuations are complete when using skipCleanup=true.
-     */
-    clearState() {
-        if (this.Graph) {
-            this.Graph.clearHeavyState();
-        }
-    }
-    /**
-     * Returns the normalized finish/stop reason from the last LLM invocation.
-     * Delegates to the underlying Graph instance.
-     */
-    getLastFinishReason() {
-        if (this.Graph && 'getLastFinishReason' in this.Graph) {
-            return this.Graph.getLastFinishReason();
-        }
-        return undefined;
-    }
-    /**
-     * Returns the ID of the last agent that produced output in a multi-agent graph.
-     * Used by auto-continuation to determine which agent's context to preserve
-     * when a response is truncated after an agent handoff.
-     * Returns undefined for single-agent graphs.
-     */
-    getLastActiveAgentId() {
-        if (this.Graph && this.Graph instanceof MultiAgentGraph) {
-            return this.Graph.getLastActiveAgentId();
-        }
-        return undefined;
-    }
-    /**
-     * Trace a guardrail execution as part of the current observability trace.
-     *
-     * For **input guardrails** (before processStream): data is queued as pending
-     * and flushed once the trace is created during processStream().
-     *
-     * For **output guardrails** (after processStream): data is sent immediately
-     * to the existing trace.
-     *
-     * @param data - Guardrail execution result from ranger's guardrail service
-     * @returns The observation ID if sent immediately, or null if queued/no handler
-     */
-    traceGuardrail(data) {
-        if (this.observabilityHandler) {
-            return this.observabilityHandler.traceGuardrail(data);
-        }
-        // No handler yet — queue for later (input guardrail before processStream)
-        this.pendingGuardrails.push(data);
-        return null;
-    }
-    /**
-     * Returns the observability trace ID for this run, or null if observability
-     * is not enabled or no trace has been created yet.
-     */
-    getTraceId() {
-        return this.observabilityHandler?.getTraceId() ?? null;
-    }
-    /**
-     * Creates a custom event callback handler that intercepts custom events
-     * and processes them through our handler registry instead of EventStreamCallbackHandler
-     */
-    createCustomEventCallback() {
-        return async (eventName, data, runId, tags, metadata) => {
-            const handler = this.handlerRegistry?.getHandler(eventName);
-            if (handler && this.Graph) {
-                return await handler.handle(eventName, data, metadata, this.Graph);
-            }
-        };
-    }
-    async processStream(inputs, config, streamOptions) {
-        if (this.graphRunnable == null) {
-            throw new Error('Run not initialized. Make sure to use Run.create() to instantiate the Run.');
-        }
-        if (!this.Graph) {
-            throw new Error('Graph not initialized. Make sure to use Run.create() to instantiate the Run.');
-        }
-        this.Graph.resetValues(streamOptions?.keepContent);
-        /** Custom event callback to intercept and handle custom events */
-        const customEventCallback = this.createCustomEventCallback();
-        const baseCallbacks = config.callbacks ?? [];
-        const streamCallbacks = streamOptions?.callbacks
-            ? this.getCallbacks(streamOptions.callbacks)
-            : [];
-        const customHandler = BaseCallbackHandler.fromMethods({
-            [Callback.CUSTOM_EVENT]: customEventCallback,
-        });
-        customHandler.awaitHandlers = true;
-        config.callbacks = baseCallbacks
-            .concat(streamCallbacks)
-            .concat(customHandler);
-        const secretKey = process.env.ILLUMA_SECRET_KEY ?? process.env.LANGFUSE_SECRET_KEY;
-        const publicKey = process.env.ILLUMA_PUBLIC_KEY ?? process.env.LANGFUSE_PUBLIC_KEY;
-        const baseUrl = process.env.ILLUMA_BASE_URL ?? process.env.LANGFUSE_BASE_URL;
-        if (isPresent(secretKey) && isPresent(publicKey) && isPresent(baseUrl)) {
-            const userId = config.configurable?.user_id;
-            const sessionId = config.configurable?.thread_id;
-            const handler = new ObservabilityCallbackHandler({
-                clientOptions: { publicKey, secretKey, baseUrl },
-                userId,
-                sessionId,
-                metadata: {
-                    messageId: this.id,
-                    parentMessageId: config.configurable?.requestBody?.parentMessageId,
-                },
-                environment: process.env.ILLUMA_ENVIRONMENT ?? process.env.LANGFUSE_TRACING_ENVIRONMENT ?? process.env.NODE_ENV,
-            });
-            this.observabilityHandler = handler;
-            config.callbacks = (config.callbacks ?? []).concat([handler]);
-        }
-        if (!this.id) {
-            throw new Error('Run ID not provided');
-        }
-        config.run_id = this.id;
-        config.configurable = Object.assign(config.configurable ?? {}, {
-            run_id: this.id,
-        });
-        const stream = this.graphRunnable.streamEvents(inputs, config, {
-            raiseError: true,
-            /**
-             * Prevent EventStreamCallbackHandler from processing custom events.
-             * Custom events are already handled via our createCustomEventCallback()
-             * which routes them through the handlerRegistry.
-             * Without this flag, EventStreamCallbackHandler throws errors when
-             * custom events are dispatched for run IDs not in its internal map
-             * (due to timing issues in parallel execution or after run cleanup).
-             */
-            ignoreCustomEvent: true,
-        });
-        for await (const event of stream) {
-            const { data, metadata, ...info } = event;
-            const eventName = info.event;
-            /** Skip custom events as they're handled by our callback */
-            if (eventName === GraphEvents.ON_CUSTOM_EVENT) {
-                continue;
-            }
-            const handler = this.handlerRegistry?.getHandler(eventName);
-            if (handler) {
-                await handler.handle(eventName, data, metadata, this.Graph);
-            }
-        }
-        // Flush any guardrails that were collected before processStream()
-        // (e.g., input moderation). Now the trace exists so they can be attached.
-        if (this.observabilityHandler && this.pendingGuardrails.length > 0) {
-            for (const guardrail of this.pendingGuardrails) {
-                this.observabilityHandler.traceGuardrail(guardrail);
-            }
-            this.pendingGuardrails = [];
-        }
-        /**
-         * Break the reference chain that keeps heavy data alive via
-         * LangGraph's internal `__pregel_scratchpad.currentTaskInput` →
-         * `@langchain/core` `RunTree.extra[lc:child_config]` →
-         * Node.js `AsyncLocalStorage` context captured by timers/promises.
-         *
-         * Without this, base64-encoded images/PDFs in message content remain
-         * reachable from lingering `Timeout` handles until GC runs.
-         */
-        if (!this.skipCleanup) {
-            if (config.configurable != null) {
-                for (const key of Object.getOwnPropertySymbols(config.configurable)) {
-                    const val = config.configurable[key];
-                    if (val != null &&
-                        typeof val === 'object' &&
-                        'currentTaskInput' in val) {
-                        val.currentTaskInput = undefined;
-                    }
-                    delete config.configurable[key];
-                }
-                config.configurable = undefined;
-            }
-            config.callbacks = undefined;
-        }
-        const result = this.returnContent
-            ? this.Graph.getContentParts()
-            : undefined;
-        if (!this.skipCleanup) {
-            this.Graph.clearHeavyState();
-        }
-        return result;
-    }
-    createSystemCallback(clientCallbacks, key) {
-        return ((...args) => {
-            const clientCallback = clientCallbacks[key];
-            if (clientCallback && this.Graph) {
-                clientCallback(this.Graph, ...args);
-            }
-        });
-    }
-    getCallbacks(clientCallbacks) {
-        return {
-            [Callback.TOOL_ERROR]: this.createSystemCallback(clientCallbacks, Callback.TOOL_ERROR),
-            [Callback.TOOL_START]: this.createSystemCallback(clientCallbacks, Callback.TOOL_START),
-            [Callback.TOOL_END]: this.createSystemCallback(clientCallbacks, Callback.TOOL_END),
-        };
-    }
-    async generateTitle({ provider, inputText, contentParts, titlePrompt, clientOptions, chainOptions, skipLanguage, titleMethod = TitleMethod.COMPLETION, titlePromptTemplate, }) {
-        const titleSecretKey = process.env.ILLUMA_SECRET_KEY ?? process.env.LANGFUSE_SECRET_KEY;
-        const titlePublicKey = process.env.ILLUMA_PUBLIC_KEY ?? process.env.LANGFUSE_PUBLIC_KEY;
-        const titleBaseUrl = process.env.ILLUMA_BASE_URL ?? process.env.LANGFUSE_BASE_URL;
-        if (chainOptions != null &&
-            isPresent(titleSecretKey) && isPresent(titlePublicKey) && isPresent(titleBaseUrl)) {
-            const userId = chainOptions.configurable?.user_id;
-            const sessionId = chainOptions.configurable?.thread_id;
-            const handler = new ObservabilityCallbackHandler({
-                clientOptions: { publicKey: titlePublicKey, secretKey: titleSecretKey, baseUrl: titleBaseUrl },
-                userId,
-                sessionId,
-                metadata: {
-                    messageId: 'title-' + this.id,
-                },
-                environment: process.env.ILLUMA_ENVIRONMENT ?? process.env.LANGFUSE_TRACING_ENVIRONMENT ?? process.env.NODE_ENV,
-            });
-            chainOptions.callbacks = (chainOptions.callbacks ?? []).concat([handler]);
-        }
-        const convoTemplate = PromptTemplate.fromTemplate(titlePromptTemplate ?? 'User: {input}\nAI: {output}');
-        const response = contentParts
-            .map((part) => {
-            if (part?.type === 'text')
-                return part.text;
-            return '';
-        })
-            .join('\n');
-        const model = this.Graph?.getNewModel({
-            provider,
-            clientOptions,
-        });
-        if (!model) {
-            return { language: '', title: '' };
-        }
-        if (isOpenAILike(provider) &&
-            (model instanceof ChatOpenAI || model instanceof AzureChatOpenAI)) {
-            model.temperature = clientOptions
-                ?.temperature;
-            model.topP = clientOptions
-                ?.topP;
-            model.frequencyPenalty = clientOptions?.frequencyPenalty;
-            model.presencePenalty = clientOptions?.presencePenalty;
-            model.n = clientOptions
-                ?.n;
-        }
-        const convoToTitleInput = new RunnableLambda({
-            func: (promptValue) => ({
-                convo: promptValue.value,
-                inputText,
-                skipLanguage,
-            }),
-        }).withConfig({ runName: 'ConvoTransform' });
-        const titleChain = titleMethod === TitleMethod.COMPLETION
-            ? await createCompletionTitleRunnable(model, titlePrompt)
-            : await createTitleRunnable(model, titlePrompt);
-        /** Pipes `convoTemplate` -> `transformer` -> `titleChain` */
-        const fullChain = convoTemplate
-            .withConfig({ runName: 'ConvoTemplate' })
-            .pipe(convoToTitleInput)
-            .pipe(titleChain)
-            .withConfig({ runName: 'TitleChain' });
-        const invokeConfig = Object.assign({}, chainOptions, {
-            run_id: this.id,
-            runId: this.id,
-        });
-        try {
-            return await fullChain.invoke({ input: inputText, output: response }, invokeConfig);
-        }
-        catch (_e) {
-            // Fallback: strip callbacks to avoid EventStream tracer errors in certain environments
-            // But preserve observability handler if it exists
-            const illumaHandler = invokeConfig.callbacks?.find((cb) => cb instanceof ObservabilityCallbackHandler);
-            const { callbacks: _cb, ...rest } = invokeConfig;
-            const safeConfig = Object.assign({}, rest, {
-                callbacks: illumaHandler ? [illumaHandler] : [],
-            });
-            return await fullChain.invoke({ input: inputText, output: response }, safeConfig);
-        }
-    }
-}
-//# sourceMappingURL=run.js.map

package/src/schemas/index.js

@@ -1,3 +0,0 @@
-// src/schemas/index.ts
-export * from './validate';
-//# sourceMappingURL=index.js.map