illuma-agents 1.0.2

package/dist/types/llm/vertexai/index.d.ts

@@ -0,0 +1,293 @@
+import { ChatGoogle } from '@langchain/google-gauth';
+import type { GoogleAIModelRequestParams, GoogleAbstractedClient } from '@langchain/google-common';
+import type { VertexAIClientOptions } from '@/types';
+/**
+ * Integration with Google Vertex AI chat models.
+ *
+ * Setup:
+ * Install `@langchain/google-vertexai` and set your stringified
+ * Vertex AI credentials as an environment variable named `GOOGLE_APPLICATION_CREDENTIALS`.
+ *
+ * ```bash
+ * npm install @langchain/google-vertexai
+ * export GOOGLE_APPLICATION_CREDENTIALS="path/to/credentials"
+ * ```
+ *
+ * ## [Constructor args](https://api.js.langchain.com/classes/_langchain_google_vertexai.index.ChatVertexAI.html#constructor.new_ChatVertexAI)
+ *
+ * ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_google_common_types.GoogleAIBaseLanguageModelCallOptions.html)
+ *
+ * Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.
+ * They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:
+ *
+ * ```typescript
+ * // When calling `.withConfig`, call options should be passed via the first argument
+ * const llmWithArgsBound = llm.withConfig({
+ *   stop: ["\n"],
+ *   tools: [...],
+ * });
+ *
+ * // When calling `.bindTools`, call options should be passed via the second argument
+ * const llmWithTools = llm.bindTools(
+ *   [...],
+ *   {
+ *     tool_choice: "auto",
+ *   }
+ * );
+ * ```
+ *
+ * ## Examples
+ *
+ * <details open>
+ * <summary><strong>Instantiate</strong></summary>
+ *
+ * ```typescript
+ * import { ChatVertexAI } from '@langchain/google-vertexai';
+ *
+ * const llm = new ChatVertexAI({
+ *   model: "gemini-1.5-pro",
+ *   temperature: 0,
+ *   // other params...
+ * });
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Invoking</strong></summary>
+ *
+ * ```typescript
+ * const input = `Translate "I love programming" into French.`;
+ *
+ * // Models also accept a list of chat messages or a formatted prompt
+ * const result = await llm.invoke(input);
+ * console.log(result);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n\nHere's why this is the best translation:\n\n* **J'adore** means \"I love\" and conveys a strong passion.\n* **Programmer** is the French verb for \"to program.\"\n\nThis translation is natural and idiomatic in French. \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 63,
+ *     "total_tokens": 72
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Streaming Chunks</strong></summary>
+ *
+ * ```typescript
+ * for await (const chunk of await llm.stream(input)) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Aggregate Streamed Chunks</strong></summary>
+ *
+ * ```typescript
+ * import { AIMessageChunk } from '@langchain/core/messages';
+ * import { concat } from '@langchain/core/utils/stream';
+ *
+ * const stream = await llm.stream(input);
+ * let full: AIMessageChunk | undefined;
+ * for await (const chunk of stream) {
+ *   full = !full ? chunk : concat(full, chunk);
+ * }
+ * console.log(full);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Bind tools</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const GetWeather = {
+ *   name: "GetWeather",
+ *   description: "Get the current weather in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const GetPopulation = {
+ *   name: "GetPopulation",
+ *   description: "Get the current population in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);
+ * const aiMsg = await llmWithTools.invoke(
+ *   "Which city is hotter today and which is bigger: LA or NY?"
+ * );
+ * console.log(aiMsg.tool_calls);
+ * ```
+ *
+ * ```txt
+ * [
+ *   {
+ *     name: 'GetPopulation',
+ *     args: { location: 'New York City, NY' },
+ *     id: '33c1c1f47e2f492799c77d2800a43912',
+ *     type: 'tool_call'
+ *   }
+ * ]
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Structured Output</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const Joke = z.object({
+ *   setup: z.string().describe("The setup of the joke"),
+ *   punchline: z.string().describe("The punchline to the joke"),
+ *   rating: z.number().optional().describe("How funny the joke is, from 1 to 10")
+ * }).describe('Joke to tell user.');
+ *
+ * const structuredLlm = llm.withStructuredOutput(Joke, { name: "Joke" });
+ * const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
+ * console.log(jokeResult);
+ * ```
+ *
+ * ```txt
+ * {
+ *   setup: 'What do you call a cat that loves to bowl?',
+ *   punchline: 'An alley cat!'
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const aiMsgForMetadata = await llm.invoke(input);
+ * console.log(aiMsgForMetadata.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Stream Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const streamForMetadata = await llm.stream(
+ *   input,
+ *   {
+ *     streamUsage: true
+ *   }
+ * );
+ * let fullForMetadata: AIMessageChunk | undefined;
+ * for await (const chunk of streamForMetadata) {
+ *   fullForMetadata = !fullForMetadata ? chunk : concat(fullForMetadata, chunk);
+ * }
+ * console.log(fullForMetadata?.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ */
+export declare class ChatVertexAI extends ChatGoogle {
+    lc_namespace: string[];
+    dynamicThinkingBudget: boolean;
+    static lc_name(): 'IllumaVertexAI';
+    constructor(fields?: VertexAIClientOptions);
+    invocationParams(options?: this['ParsedCallOptions'] | undefined): GoogleAIModelRequestParams;
+    buildConnection(fields: VertexAIClientOptions, client: GoogleAbstractedClient): void;
+}

package/dist/types/messages/core.d.ts

@@ -0,0 +1,14 @@
+import { AIMessageChunk, HumanMessage, ToolMessage, AIMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { Providers } from '@/common';
+export declare function getConverseOverrideMessage({ userMessage, lastMessageX, lastMessageY, }: {
+    userMessage: string[];
+    lastMessageX: AIMessageChunk | null;
+    lastMessageY: ToolMessage;
+}): HumanMessage;
+export declare function modifyDeltaProperties(provider: Providers, obj?: AIMessageChunk): AIMessageChunk | undefined;
+export declare function formatAnthropicMessage(message: AIMessageChunk): AIMessage;
+export declare function convertMessagesToContent(messages: BaseMessage[]): t.MessageContentComplex[];
+export declare function formatAnthropicArtifactContent(messages: BaseMessage[]): void;
+export declare function formatArtifactPayload(messages: BaseMessage[]): void;
+export declare function findLastIndex<T>(array: T[], predicate: (value: T) => boolean): number;

package/dist/types/messages/format.d.ts

@@ -0,0 +1,113 @@
+import { AIMessage, ToolMessage, BaseMessage, HumanMessage, SystemMessage } from '@langchain/core/messages';
+import type { MessageContentImageUrl } from '@langchain/core/messages';
+import type { MessageContentComplex, TPayload } from '@/types';
+import { Providers } from '@/common';
+interface MediaMessageParams {
+    message: {
+        role: string;
+        content: string;
+        name?: string;
+        [key: string]: any;
+    };
+    mediaParts: MessageContentComplex[];
+    endpoint?: Providers;
+}
+/**
+ * Formats a message with media content (images, documents, videos, audios) to API payload format.
+ *
+ * @param params - The parameters for formatting.
+ * @returns - The formatted message.
+ */
+export declare const formatMediaMessage: ({ message, endpoint, mediaParts, }: MediaMessageParams) => {
+    role: string;
+    content: MessageContentComplex[];
+    name?: string;
+    [key: string]: any;
+};
+interface MessageInput {
+    role?: string;
+    _name?: string;
+    sender?: string;
+    text?: string;
+    content?: string | MessageContentComplex[];
+    image_urls?: MessageContentImageUrl[];
+    documents?: MessageContentComplex[];
+    videos?: MessageContentComplex[];
+    audios?: MessageContentComplex[];
+    lc_id?: string[];
+    [key: string]: any;
+}
+interface FormatMessageParams {
+    message: MessageInput;
+    userName?: string;
+    assistantName?: string;
+    endpoint?: Providers;
+    langChain?: boolean;
+}
+interface FormattedMessage {
+    role: string;
+    content: string | MessageContentComplex[];
+    name?: string;
+    [key: string]: any;
+}
+/**
+ * Formats a message to OpenAI payload format based on the provided options.
+ *
+ * @param params - The parameters for formatting.
+ * @returns - The formatted message.
+ */
+export declare const formatMessage: ({ message, userName, endpoint, assistantName, langChain, }: FormatMessageParams) => FormattedMessage | HumanMessage | AIMessage | SystemMessage;
+/**
+ * Formats an array of messages for LangChain.
+ *
+ * @param messages - The array of messages to format.
+ * @param formatOptions - The options for formatting each message.
+ * @returns - The array of formatted LangChain messages.
+ */
+export declare const formatLangChainMessages: (messages: Array<MessageInput>, formatOptions: Omit<FormatMessageParams, "message" | "langChain">) => Array<HumanMessage | AIMessage | SystemMessage>;
+interface LangChainMessage {
+    lc_kwargs?: {
+        additional_kwargs?: Record<string, any>;
+        [key: string]: any;
+    };
+    kwargs?: {
+        additional_kwargs?: Record<string, any>;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+/**
+ * Formats a LangChain message object by merging properties from `lc_kwargs` or `kwargs` and `additional_kwargs`.
+ *
+ * @param message - The message object to format.
+ * @returns - The formatted LangChain message.
+ */
+export declare const formatFromLangChain: (message: LangChainMessage) => Record<string, any>;
+/**
+ * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
+ *
+ * @param payload - The array of messages to format.
+ * @param indexTokenCountMap - Optional map of message indices to token counts.
+ * @param tools - Optional set of tool names that are allowed in the request.
+ * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
+ */
+export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number>, tools?: Set<string>) => {
+    messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
+    indexTokenCountMap?: Record<number, number>;
+};
+/**
+ * Formats an array of messages for LangChain, making sure all content fields are strings
+ * @param payload - The array of messages to format.
+ * @returns - The array of formatted LangChain messages, including ToolMessages for tool calls.
+ */
+export declare const formatContentStrings: (payload: Array<BaseMessage>) => Array<BaseMessage>;
+/**
+ * Adds a value at key 0 for system messages and shifts all key indices by one in an indexTokenCountMap.
+ * This is useful when adding a system message at the beginning of a conversation.
+ *
+ * @param indexTokenCountMap - The original map of message indices to token counts
+ * @param instructionsTokenCount - The token count for the system message to add at index 0
+ * @returns A new map with the system message at index 0 and all other indices shifted by 1
+ */
+export declare function shiftIndexTokenCountMap(indexTokenCountMap: Record<number, number>, instructionsTokenCount: number): Record<number, number>;
+export {};

package/dist/types/messages/ids.d.ts

@@ -0,0 +1,3 @@
+import type { Graph } from '@/graphs';
+import type * as t from '@/types';
+export declare const getMessageId: (stepKey: string, graph: Graph<t.BaseGraphState>, returnExistingId?: boolean) => string | undefined;

package/dist/types/messages/index.d.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './ids';
+export * from './prune';
+export * from './format';

package/dist/types/messages/prune.d.ts

@@ -0,0 +1,51 @@
+import { BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import type { TokenCounter } from '@/types/run';
+import { ContentTypes, Providers } from '@/common';
+export type PruneMessagesFactoryParams = {
+    provider?: Providers;
+    maxTokens: number;
+    startIndex: number;
+    tokenCounter: TokenCounter;
+    indexTokenCountMap: Record<string, number | undefined>;
+    thinkingEnabled?: boolean;
+};
+export type PruneMessagesParams = {
+    messages: BaseMessage[];
+    usageMetadata?: Partial<UsageMetadata>;
+    startType?: ReturnType<BaseMessage['getType']>;
+};
+/**
+ * Calculates the total tokens from a single usage object
+ *
+ * @param usage The usage metadata object containing token information
+ * @returns An object containing the total input and output tokens
+ */
+export declare function calculateTotalTokens(usage: Partial<UsageMetadata>): UsageMetadata;
+export type PruningResult = {
+    context: BaseMessage[];
+    remainingContextTokens: number;
+    messagesToRefine: BaseMessage[];
+    thinkingStartIndex?: number;
+};
+/**
+ * Processes an array of messages and returns a context of messages that fit within a specified token limit.
+ * It iterates over the messages from newest to oldest, adding them to the context until the token limit is reached.
+ *
+ * @param options Configuration options for processing messages
+ * @returns Object containing the message context, remaining tokens, messages not included, and summary index
+ */
+export declare function getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, indexTokenCountMap, startType: _startType, thinkingEnabled, tokenCounter, thinkingStartIndex: _thinkingStartIndex, reasoningType, }: {
+    messages: BaseMessage[];
+    maxContextTokens: number;
+    indexTokenCountMap: Record<string, number | undefined>;
+    startType?: string | string[];
+    thinkingEnabled?: boolean;
+    tokenCounter: TokenCounter;
+    thinkingStartIndex?: number;
+    reasoningType?: ContentTypes.THINKING | ContentTypes.REASONING_CONTENT;
+}): PruningResult;
+export declare function checkValidNumber(value: unknown): value is number;
+export declare function createPruneMessages(factoryParams: PruneMessagesFactoryParams): (params: PruneMessagesParams) => {
+    context: BaseMessage[];
+    indexTokenCountMap: Record<string, number | undefined>;
+};

package/dist/types/mockStream.d.ts

@@ -0,0 +1,32 @@
+import type * as t from '@/types';
+export declare const createMockStream: (options?: {
+    text?: string;
+    reasoningText?: string;
+    streamRate?: number;
+    reasoningKey?: "reasoning" | "reasoning_content";
+}) => () => AsyncGenerator<t.CustomChunk>;
+/**
+(async function testStream(): Promise<void> {
+  const runId = nanoid();
+
+  const streamHandler = new SplitStreamHandler({
+    runId,
+    handlers: {
+      [GraphEvents.ON_RUN_STEP]: (data): void => {
+        console.dir(data, { depth: null });
+      },
+      [GraphEvents.ON_MESSAGE_DELTA]: (): void => {
+        // console.dir(data, { depth: null });
+      },
+    },
+  });
+  const stream = createMockStream({
+    reasoningText: 'This is a test reasoning text.',
+    streamRate: 5,
+  })();
+
+  for await (const chunk of stream) {
+    streamHandler.handle(chunk);
+  }
+})();
+ */ 

package/dist/types/prompts/collab.d.ts

@@ -0,0 +1 @@
+export declare const supervisorPrompt = "You are a supervisor tasked with managing a conversation between the\nfollowing workers: {members}. Given the following user request,\nrespond with the worker to act next. Each worker will perform a\ntask and respond with their results and status. Multiple workers can work at once, and they can use multiple tools at once. Each worker can run their tools multiple times per task. When finished,\nrespond with FINISH.";

package/dist/types/prompts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './collab';
+export * from './taskmanager';

package/dist/types/prompts/taskmanager.d.ts

@@ -0,0 +1,41 @@
+export declare 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.\n\nCRITICAL GUIDELINES:\n1. The user's request is your CHIEF CONCERN. Every action must directly contribute to fulfilling this request.\n2. Aim to complete the entire task in NO MORE THAN 2-3 TURNS, unless explicitly instructed otherwise.\n3. Eliminate all superfluous activity. Each task must be essential to achieving the user's goal.\n4. Assign no more than 5 tasks per turn, and only if absolutely necessary.\n5. Be concise and direct in your task assignments.\n6. End the process IMMEDIATELY once the user's request is fulfilled by setting 'end' to true and assigning no new tasks.\n\nYour responsibilities:\n1. Analyze the user's request and break it down into the minimum necessary subtasks.\n2. Assign these essential tasks to the most appropriate team members based on their skills and tools.\n3. Prioritize tasks to ensure the most efficient path to completion.\n4. Continuously evaluate if the user's request has been fully addressed.\n5. End the process IMMEDIATELY once the user's request is fulfilled.\n\nTask Assignment Guidelines:\n- Assign only the most crucial tasks required to meet the user's needs.\n- Multiple tasks can be assigned to the same team member if it improves efficiency.\n- Always specify the tool to use if applicable.\n- Consider task dependencies to minimize the number of turns.\n\nAfter each round:\n- Critically assess if the user's request has been fully addressed.\n- If more work is genuinely needed, assign only the most essential remaining tasks.\n- 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.\n\nREMEMBER: 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 declare 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 declare const assignTasksFunctionParameters: {
+    type: string;
+    properties: {
+        tasks: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    member: {
+                        type: string;
+                        description: string;
+                    };
+                    description: {
+                        type: string;
+                        description: string;
+                    };
+                    tool: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+            };
+            description: string;
+        };
+    };
+    required: string[];
+};
+export declare const endProcessFunctionDescription = "End the process when the user's request has been fulfilled.";
+export declare const endProcessFunctionParameters: {
+    type: string;
+    properties: {
+        reason: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+};

package/dist/types/run.d.ts

@@ -0,0 +1,30 @@
+import './instrumentation';
+import type { MessageContentComplex, BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ClientCallbacks, SystemCallbacks } from '@/graphs/Graph';
+import type * as t from '@/types';
+import { Providers } from '@/common';
+import { StandardGraph } from '@/graphs/Graph';
+export declare const defaultOmitOptions: Set<string>;
+export declare class Run<T extends t.BaseGraphState> {
+    graphRunnable?: t.CompiledWorkflow<T, Partial<T>, string>;
+    private handlerRegistry;
+    id: string;
+    Graph: StandardGraph | undefined;
+    provider: Providers | undefined;
+    returnContent: boolean;
+    private constructor();
+    private createStandardGraph;
+    static create<T extends t.BaseGraphState>(config: t.RunConfig): Promise<Run<T>>;
+    getRunMessages(): BaseMessage[] | undefined;
+    processStream(inputs: t.IState, config: Partial<RunnableConfig> & {
+        version: 'v1' | 'v2';
+        run_id?: string;
+    }, streamOptions?: t.EventStreamOptions): Promise<MessageContentComplex[] | undefined>;
+    private createSystemCallback;
+    getCallbacks(clientCallbacks: ClientCallbacks): SystemCallbacks;
+    generateTitle({ provider, inputText, contentParts, titlePrompt, clientOptions, chainOptions, skipLanguage, omitOptions, titleMethod, titlePromptTemplate, }: t.RunTitleOptions): Promise<{
+        language?: string;
+        title?: string;
+    }>;
+}

package/dist/types/scripts/abort.d.ts

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

package/dist/types/scripts/ant_web_search.d.ts

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

package/dist/types/scripts/args.d.ts

@@ -0,0 +1,7 @@
+import { Providers } from '@/common';
+export declare function getArgs(): Promise<{
+    userName: string;
+    location: string;
+    provider: Providers;
+    currentDate: string;
+}>;

package/dist/types/scripts/caching.d.ts

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

package/dist/types/scripts/cli.d.ts

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

package/dist/types/scripts/cli2.d.ts

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

package/dist/types/scripts/cli3.d.ts

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

package/dist/types/scripts/cli4.d.ts

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

package/dist/types/scripts/cli5.d.ts

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

package/dist/types/scripts/code_exec.d.ts

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

package/dist/types/scripts/code_exec_files.d.ts

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

package/dist/types/scripts/code_exec_simple.d.ts

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

package/dist/types/scripts/content.d.ts

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

package/dist/types/scripts/empty_input.d.ts

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

package/dist/types/scripts/image.d.ts

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

package/dist/types/scripts/memory.d.ts

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

package/dist/types/scripts/search.d.ts

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

package/dist/types/scripts/simple.d.ts

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

package/dist/types/scripts/stream.d.ts

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

package/dist/types/scripts/thinking.d.ts

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

package/dist/types/scripts/tools.d.ts

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