@crewai-ts/core 0.1.2 → 0.1.5

package/dist/formatter.d.ts

@@ -0,0 +1,7 @@
+import type { Task } from "./task.js";
+import type { TaskOutput } from "./outputs.js";
+export declare const DIVIDERS = "\n\n----------\n\n";
+export declare function aggregateRawOutputsFromTaskOutputs(taskOutputs: readonly TaskOutput[]): string;
+export declare const aggregate_raw_outputs_from_task_outputs: typeof aggregateRawOutputsFromTaskOutputs;
+export declare function aggregateRawOutputsFromTasks(tasks: readonly Task[] | null | undefined): string;
+export declare const aggregate_raw_outputs_from_tasks: typeof aggregateRawOutputsFromTasks;

package/dist/guardrail.d.ts

@@ -0,0 +1,95 @@
+import type { LiteAgentOutput } from "./lite-agent-output.js";
+import type { TaskOutput } from "./outputs.js";
+import { type LLM } from "./llm.js";
+export type GuardrailCallable = (output: TaskOutput | LiteAgentOutput) => readonly [boolean, unknown];
+export declare const GuardrailCallable: FunctionConstructor;
+export type GuardrailType = GuardrailCallable | string;
+export declare const GuardrailType: Readonly<{
+    kind: "GuardrailType";
+}>;
+export type GuardrailsType = readonly GuardrailType[] | GuardrailType;
+export declare const GuardrailsType: Readonly<{
+    kind: "GuardrailsType";
+}>;
+export type AsyncGuardrailCallable = (output: TaskOutput | LiteAgentOutput) => Promise<readonly [boolean, unknown]>;
+export declare function _is_coroutine<T>(obj: T | PromiseLike<T>): obj is PromiseLike<T>;
+export declare function _run_coroutine_sync<T>(coro: PromiseLike<T>): Promise<T>;
+export declare class GuardrailResult {
+    readonly success: boolean;
+    readonly result: unknown;
+    readonly error: unknown;
+    constructor(options: {
+        success: boolean;
+        result?: unknown;
+        error?: unknown;
+    });
+    static fromTuple(result: readonly [boolean, unknown]): GuardrailResult;
+    static from_tuple(result: readonly [boolean, unknown]): GuardrailResult;
+    static validateResultErrorExclusivity(value: unknown, info?: {
+        data?: Record<string, unknown>;
+    }): unknown;
+    static validate_result_error_exclusivity(value: unknown, info?: {
+        data?: Record<string, unknown>;
+    }): unknown;
+}
+export declare function serializeGuardrailForJson(value: unknown, fieldName?: string): string | null;
+export declare const serialize_guardrail_for_json: typeof serializeGuardrailForJson;
+export declare function serializeGuardrailsForJson(value: unknown, fieldName?: string): readonly string[] | string | null;
+export declare const serialize_guardrails_for_json: typeof serializeGuardrailsForJson;
+export declare function processGuardrail(output: TaskOutput | LiteAgentOutput, guardrail: GuardrailCallable | null | undefined, options?: {
+    retryCount?: number;
+    retry_count?: number;
+    fromAgent?: unknown;
+    from_agent?: unknown;
+    fromTask?: unknown;
+    from_task?: unknown;
+    eventSource?: unknown;
+    event_source?: unknown;
+}): GuardrailResult;
+export declare const process_guardrail: typeof processGuardrail;
+export type LLMGuardrailOptions = {
+    description: string;
+    llm: LLM;
+};
+export declare class LLMGuardrailResult {
+    readonly valid: boolean;
+    readonly feedback: string | null;
+    constructor(options: {
+        valid: boolean;
+        feedback?: string | null;
+    });
+}
+export declare class LLMGuardrail {
+    readonly description: string;
+    readonly llm: LLM;
+    constructor(options: LLMGuardrailOptions);
+    constructor(description: string, llm: LLM);
+    validateOutput(taskOutput: TaskOutput | LiteAgentOutput): Promise<LLMGuardrailResult>;
+    _validate_output(taskOutput: TaskOutput | LiteAgentOutput): Promise<LLMGuardrailResult>;
+    call(taskOutput: TaskOutput | LiteAgentOutput): Promise<readonly [boolean, unknown]>;
+    __call__(taskOutput: TaskOutput | LiteAgentOutput): Promise<readonly [boolean, unknown]>;
+    asGuardrail(): AsyncGuardrailCallable;
+}
+export type HallucinationGuardrailOptions = {
+    llm: LLM;
+    context?: string | null;
+    threshold?: number | null;
+    toolResponse?: string;
+    tool_response?: string;
+};
+export type HallucinationGuardrailHook = (guardrail: HallucinationGuardrail, taskOutput: TaskOutput | LiteAgentOutput) => readonly [boolean, unknown];
+export declare function setHallucinationGuardrailHook(hook: HallucinationGuardrailHook | null): void;
+export declare const set_hallucination_guardrail_hook: typeof setHallucinationGuardrailHook;
+export declare class HallucinationGuardrail {
+    readonly context: string | null;
+    readonly llm: LLM;
+    readonly threshold: number | null;
+    readonly toolResponse: string;
+    readonly tool_response: string;
+    constructor(options: HallucinationGuardrailOptions);
+    constructor(llm: LLM, context?: string | null, threshold?: number | null, toolResponse?: string);
+    get description(): string;
+    call(taskOutput: TaskOutput | LiteAgentOutput): readonly [boolean, unknown];
+    __call__(taskOutput: TaskOutput | LiteAgentOutput): readonly [boolean, unknown];
+    asGuardrail(): GuardrailCallable;
+}

package/dist/hooks.d.ts

@@ -0,0 +1,241 @@
+import type { LLMResponse } from "./llm.js";
+import type { LLM, LLMMessage, MaybePromise, Tool } from "./types.js";
+export declare class LLMCallHookContext {
+    readonly executor: unknown;
+    readonly agent: unknown;
+    readonly task: unknown;
+    readonly crew: unknown;
+    readonly llm: LLM | string | null | undefined;
+    readonly iterations: number;
+    readonly messages: LLMMessage[];
+    response: LLMResponse | null;
+    constructor(options?: {
+        executor?: unknown;
+        messages?: LLMMessage[];
+        llm?: LLM | string | null;
+        agent?: unknown;
+        task?: unknown;
+        crew?: unknown;
+        iterations?: number;
+        response?: LLMResponse | null;
+    });
+    requestHumanInput(prompt: string, defaultMessage?: string): string;
+    request_human_input(prompt: string, defaultMessage?: string): string;
+}
+export declare class ToolCallHookContext {
+    readonly toolName: string;
+    readonly tool_name: string;
+    readonly tool: Tool;
+    readonly agent: unknown;
+    readonly task: unknown;
+    readonly crew: unknown;
+    readonly toolInput: Record<string, unknown>;
+    readonly tool_input: Record<string, unknown>;
+    toolResult: unknown;
+    tool_result: unknown;
+    constructor(options: {
+        toolName?: string;
+        tool_name?: string;
+        toolInput?: Record<string, unknown>;
+        tool_input?: Record<string, unknown>;
+        tool: Tool;
+        agent?: unknown;
+        task?: unknown;
+        crew?: unknown;
+        toolResult?: unknown;
+        tool_result?: unknown;
+    });
+    requestHumanInput(prompt: string, defaultMessage?: string): string;
+    request_human_input(prompt: string, defaultMessage?: string): string;
+}
+export type BeforeLLMCallHook = (context: LLMCallHookContext) => MaybePromise<boolean | null | undefined>;
+export type AfterLLMCallHook = (context: LLMCallHookContext) => MaybePromise<string | null | undefined>;
+export type BeforeToolCallHook = (context: ToolCallHookContext) => MaybePromise<boolean | null | undefined>;
+export type AfterToolCallHook = (context: ToolCallHookContext) => MaybePromise<string | null | undefined>;
+export declare const ContextT: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const ReturnT: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const P: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const R: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const U: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const Hook: Readonly<{
+    kind: "Hook";
+}>;
+export declare const HTTPTransportKwargs: Readonly<{
+    kind: "HTTPTransportKwargs";
+}>;
+export type HTTPTransportKwargs = Record<string, unknown>;
+export declare abstract class BaseInterceptor<TOutbound = unknown, TInbound = unknown> {
+    abstract on_outbound(message: TOutbound): TOutbound;
+    abstract on_inbound(message: TInbound): TInbound;
+    static __get_pydantic_core_schema__(): {
+        type: "plain-validator";
+        validator: (value: unknown) => BaseInterceptor;
+        serialization: {
+            type: "identity";
+        };
+    };
+    static validateInterceptor(value: unknown): BaseInterceptor;
+    static validate_interceptor(value: unknown): BaseInterceptor;
+    aon_outbound(message: TOutbound): Promise<TOutbound>;
+    aon_inbound(message: TInbound): Promise<TInbound>;
+}
+export declare function _validate_interceptor(value: unknown): BaseInterceptor;
+export declare class AsyncHTTPTransport {
+    readonly interceptor: BaseInterceptor;
+    readonly kwargs: HTTPTransportKwargs;
+    constructor(interceptor: BaseInterceptor, kwargs?: HTTPTransportKwargs);
+    handle_async_request(request: unknown): Promise<unknown>;
+}
+export declare class HTTPTransport {
+    readonly interceptor: BaseInterceptor;
+    readonly kwargs: HTTPTransportKwargs;
+    constructor(interceptor: BaseInterceptor, kwargs?: HTTPTransportKwargs);
+    handle_request(request: unknown): unknown;
+}
+export declare const BeforeLLMCallHook: Readonly<{
+    kind: "BeforeLLMCallHook";
+}>;
+export declare const AfterLLMCallHook: Readonly<{
+    kind: "AfterLLMCallHook";
+}>;
+export declare const BeforeToolCallHook: Readonly<{
+    kind: "BeforeToolCallHook";
+}>;
+export declare const AfterToolCallHook: Readonly<{
+    kind: "AfterToolCallHook";
+}>;
+export declare const BeforeLLMCallHookType: Readonly<{
+    kind: "BeforeLLMCallHook";
+}>;
+export declare const AfterLLMCallHookType: Readonly<{
+    kind: "AfterLLMCallHook";
+}>;
+export declare const BeforeToolCallHookType: Readonly<{
+    kind: "BeforeToolCallHook";
+}>;
+export declare const AfterToolCallHookType: Readonly<{
+    kind: "AfterToolCallHook";
+}>;
+export declare const BeforeLLMCallHookCallable: Readonly<{
+    kind: "BeforeLLMCallHook";
+}>;
+export declare const AfterLLMCallHookCallable: Readonly<{
+    kind: "AfterLLMCallHook";
+}>;
+export declare const BeforeToolCallHookCallable: Readonly<{
+    kind: "BeforeToolCallHook";
+}>;
+export declare const AfterToolCallHookCallable: Readonly<{
+    kind: "AfterToolCallHook";
+}>;
+declare class HookMethod {
+    readonly _meth: (...args: unknown[]) => unknown;
+    readonly agents: readonly string[] | null;
+    readonly tools: readonly string[] | null;
+    constructor(method: (...args: unknown[]) => unknown, options?: {
+        agents?: readonly string[] | null;
+        tools?: readonly string[] | null;
+    });
+    call(...args: unknown[]): unknown;
+    __call__(...args: unknown[]): unknown;
+}
+export declare class BeforeLLMCallHookMethod extends HookMethod {
+    readonly is_before_llm_call_hook = true;
+    constructor(method: (...args: unknown[]) => unknown, agents?: readonly string[] | null);
+}
+export declare class AfterLLMCallHookMethod extends HookMethod {
+    readonly is_after_llm_call_hook = true;
+    constructor(method: (...args: unknown[]) => unknown, agents?: readonly string[] | null);
+}
+export declare class BeforeToolCallHookMethod extends HookMethod {
+    readonly is_before_tool_call_hook = true;
+    constructor(method: (...args: unknown[]) => unknown, tools?: readonly string[] | null, agents?: readonly string[] | null);
+}
+export declare class AfterToolCallHookMethod extends HookMethod {
+    readonly is_after_tool_call_hook = true;
+    constructor(method: (...args: unknown[]) => unknown, tools?: readonly string[] | null, agents?: readonly string[] | null);
+}
+export declare function registerBeforeLlmCallHook(hook: BeforeLLMCallHook): void;
+export declare const register_before_llm_call_hook: typeof registerBeforeLlmCallHook;
+export declare function registerAfterLlmCallHook(hook: AfterLLMCallHook): void;
+export declare const register_after_llm_call_hook: typeof registerAfterLlmCallHook;
+export declare function getBeforeLlmCallHooks(): BeforeLLMCallHook[];
+export declare const get_before_llm_call_hooks: typeof getBeforeLlmCallHooks;
+export declare function getAfterLlmCallHooks(): AfterLLMCallHook[];
+export declare const get_after_llm_call_hooks: typeof getAfterLlmCallHooks;
+export declare function unregisterBeforeLlmCallHook(hook: BeforeLLMCallHook): boolean;
+export declare const unregister_before_llm_call_hook: typeof unregisterBeforeLlmCallHook;
+export declare function unregisterAfterLlmCallHook(hook: AfterLLMCallHook): boolean;
+export declare const unregister_after_llm_call_hook: typeof unregisterAfterLlmCallHook;
+export declare function clearBeforeLlmCallHooks(): number;
+export declare const clear_before_llm_call_hooks: typeof clearBeforeLlmCallHooks;
+export declare function clearAfterLlmCallHooks(): number;
+export declare const clear_after_llm_call_hooks: typeof clearAfterLlmCallHooks;
+export declare function clearAllLlmCallHooks(): [number, number];
+export declare const clear_all_llm_call_hooks: typeof clearAllLlmCallHooks;
+export declare function registerBeforeToolCallHook(hook: BeforeToolCallHook): void;
+export declare const register_before_tool_call_hook: typeof registerBeforeToolCallHook;
+export declare function registerAfterToolCallHook(hook: AfterToolCallHook): void;
+export declare const register_after_tool_call_hook: typeof registerAfterToolCallHook;
+export declare function getBeforeToolCallHooks(): BeforeToolCallHook[];
+export declare const get_before_tool_call_hooks: typeof getBeforeToolCallHooks;
+export declare function getAfterToolCallHooks(): AfterToolCallHook[];
+export declare const get_after_tool_call_hooks: typeof getAfterToolCallHooks;
+export declare function unregisterBeforeToolCallHook(hook: BeforeToolCallHook): boolean;
+export declare const unregister_before_tool_call_hook: typeof unregisterBeforeToolCallHook;
+export declare function unregisterAfterToolCallHook(hook: AfterToolCallHook): boolean;
+export declare const unregister_after_tool_call_hook: typeof unregisterAfterToolCallHook;
+export declare function clearBeforeToolCallHooks(): number;
+export declare const clear_before_tool_call_hooks: typeof clearBeforeToolCallHooks;
+export declare function clearAfterToolCallHooks(): number;
+export declare const clear_after_tool_call_hooks: typeof clearAfterToolCallHooks;
+export declare function clearAllToolCallHooks(): [number, number];
+export declare const clear_all_tool_call_hooks: typeof clearAllToolCallHooks;
+export declare function clearAllGlobalHooks(): {
+    llm_hooks: [number, number];
+    tool_hooks: [number, number];
+    total: [number, number];
+};
+export declare const clear_all_global_hooks: typeof clearAllGlobalHooks;
+export type RegisteredCrewScopedHook = [
+    "before_llm_call" | "after_llm_call" | "before_tool_call" | "after_tool_call",
+    BeforeLLMCallHook | AfterLLMCallHook | BeforeToolCallHook | AfterToolCallHook
+];
+export declare function registerCrewScopedHooks(instance: object): RegisteredCrewScopedHook[];
+export declare function beforeLlmCall(hook: BeforeLLMCallHook, context?: ClassMethodDecoratorContext): BeforeLLMCallHook;
+export declare function beforeLlmCall(options: {
+    agents?: readonly string[];
+}): MethodDecorator;
+export declare const before_llm_call: typeof beforeLlmCall;
+export declare function afterLlmCall(hook: AfterLLMCallHook, context?: ClassMethodDecoratorContext): AfterLLMCallHook;
+export declare function afterLlmCall(options: {
+    agents?: readonly string[];
+}): MethodDecorator;
+export declare const after_llm_call: typeof afterLlmCall;
+export declare function beforeToolCall(hook: BeforeToolCallHook, context?: ClassMethodDecoratorContext): BeforeToolCallHook;
+export declare function beforeToolCall(options: {
+    tools?: readonly string[];
+    agents?: readonly string[];
+}): MethodDecorator;
+export declare const before_tool_call: typeof beforeToolCall;
+export declare function afterToolCall(hook: AfterToolCallHook, context?: ClassMethodDecoratorContext): AfterToolCallHook;
+export declare function afterToolCall(options: {
+    tools?: readonly string[];
+    agents?: readonly string[];
+}): MethodDecorator;
+export declare const after_tool_call: typeof afterToolCall;
+export declare function runBeforeLlmCallHooks(context: LLMCallHookContext): Promise<void>;
+export declare function runAfterLlmCallHooks(context: LLMCallHookContext): Promise<LLMResponse>;
+export declare function runBeforeToolCallHooks(context: ToolCallHookContext): Promise<void>;
+export declare function runAfterToolCallHooks(context: ToolCallHookContext): Promise<unknown>;
+export {};

package/dist/human-input.d.ts

@@ -0,0 +1,74 @@
+import type { TaskOutput } from "./outputs.js";
+export type HumanInputRequest = {
+    taskName: string | null;
+    taskDescription: string;
+    expectedOutput: string;
+    output: TaskOutput;
+};
+export type HumanInputProvider = {
+    requestFeedback: (request: HumanInputRequest) => string | Promise<string>;
+    setupMessages?: (context: ExecutorContext) => boolean;
+    setup_messages?: (context: ExecutorContext) => boolean;
+    postSetupMessages?: (context: ExecutorContext) => void;
+    post_setup_messages?: (context: ExecutorContext) => void;
+    handleFeedback?: (formattedAnswer: unknown, context: ExecutorContext) => unknown;
+    handle_feedback?: (formatted_answer: unknown, context: ExecutorContext) => unknown;
+    handleFeedbackAsync?: (formattedAnswer: unknown, context: AsyncExecutorContext) => Promise<unknown>;
+    handle_feedback_async?: (formatted_answer: unknown, context: AsyncExecutorContext) => Promise<unknown>;
+};
+export type ExecutorContext = {
+    task?: unknown;
+    crew?: unknown;
+    messages: unknown[];
+    askForHumanInput?: boolean;
+    ask_for_human_input?: boolean;
+    llm?: unknown;
+    agent?: unknown;
+    _invokeLoop?: () => unknown;
+    _invoke_loop?: () => unknown;
+    _isTrainingMode?: () => boolean;
+    _is_training_mode?: () => boolean;
+    _handleCrewTrainingOutput?: (result: unknown, humanFeedback?: string | null) => void;
+    _handle_crew_training_output?: (result: unknown, human_feedback?: string | null) => void;
+    _formatFeedbackMessage?: (feedback: string) => unknown;
+    _format_feedback_message?: (feedback: string) => unknown;
+};
+export type AsyncExecutorContext = ExecutorContext & {
+    _ainvokeLoop?: () => Promise<unknown>;
+    _ainvoke_loop?: () => Promise<unknown>;
+};
+export declare const HumanInputProvider: Readonly<{
+    kind: "HumanInputProvider";
+}>;
+export declare const ExecutorContext: Readonly<{
+    kind: "ExecutorContext";
+}>;
+export declare const AsyncExecutorContext: Readonly<{
+    kind: "AsyncExecutorContext";
+}>;
+export declare class SyncHumanInputProvider implements HumanInputProvider {
+    requestFeedback(request: HumanInputRequest): string | Promise<string>;
+    setupMessages(_context: ExecutorContext): boolean;
+    setup_messages(context: ExecutorContext): boolean;
+    postSetupMessages(_context: ExecutorContext): void;
+    post_setup_messages(context: ExecutorContext): void;
+    handleFeedback(formattedAnswer: unknown, context: ExecutorContext): unknown;
+    handle_feedback(formatted_answer: unknown, context: ExecutorContext): unknown;
+    handleFeedbackAsync(formattedAnswer: unknown, context: AsyncExecutorContext): Promise<unknown>;
+    handle_feedback_async(formatted_answer: unknown, context: AsyncExecutorContext): Promise<unknown>;
+    static _get_output_string(answer: unknown): string;
+    static _handle_training_feedback(initialAnswer: unknown, feedback: string, context: ExecutorContext): unknown;
+    _handle_training_feedback(initialAnswer: unknown, feedback: string, context: ExecutorContext): unknown;
+    _handle_regular_feedback(currentAnswer: unknown, initialFeedback: string, context: ExecutorContext): unknown;
+    static _handle_training_feedback_async(initialAnswer: unknown, feedback: string, context: AsyncExecutorContext): Promise<unknown>;
+    _handle_training_feedback_async(initialAnswer: unknown, feedback: string, context: AsyncExecutorContext): Promise<unknown>;
+    _handle_regular_feedback_async(currentAnswer: unknown, initialFeedback: string, context: AsyncExecutorContext): Promise<unknown>;
+    _prompt_input(crew?: unknown): string;
+    _prompt_input_async(crew?: unknown): Promise<string>;
+}
+export declare function _async_readline(): Promise<string>;
+export declare function getHumanInputProvider(): HumanInputProvider;
+export declare function setHumanInputProvider(provider: HumanInputProvider | null): HumanInputProvider | null;
+export declare function get_provider(): HumanInputProvider;
+export declare function set_provider(provider: HumanInputProvider): HumanInputProvider | null;
+export declare function reset_provider(token: HumanInputProvider | null): void;

package/dist/i18n.d.ts

@@ -0,0 +1,26 @@
+export type PromptKind = "slices" | "errors" | "tools" | "reasoning" | "planning" | "hierarchical_manager_agent" | "memory";
+export type PromptLeaf = string | Record<string, string>;
+export type PromptCatalog = Record<string, Record<string, PromptLeaf>>;
+export declare class I18N {
+    readonly promptFile: string | null;
+    readonly prompt_file: string | null;
+    private prompts;
+    constructor(options?: {
+        promptFile?: string | null;
+        prompt_file?: string | null;
+        prompts?: PromptCatalog;
+    });
+    loadPrompts(): this;
+    load_prompts(): this;
+    slice(slice: string): string;
+    errors(error: string): string;
+    tools(tool: string): PromptLeaf;
+    memory(key: string): string;
+    retrieve(kind: PromptKind, key: string): PromptLeaf;
+    private retrieveString;
+}
+export declare function getI18N(promptFile?: string | null): I18N;
+export declare function clearI18NCache(): void;
+export declare const I18N_DEFAULT: I18N;
+export declare const get_i18n: typeof getI18N;
+export declare const clear_i18n_cache: typeof clearI18NCache;

package/dist/index.cjs

@@ -46193,6 +46193,7 @@ function readStringNumberBooleanRecord(value) {
 
 // src/provider-completions.ts
 init_cjs_shims();
+init_string_utils();
 var TOOL_SEARCH_TOOL_TYPES = Object.freeze([
   "tool_search_tool_regex_20251119",
   "tool_search_tool_bm25_20251119"
@@ -47347,33 +47348,37 @@ var GeminiCompletion = class _GeminiCompletion extends ConfiguredLLM {
     delete generationConfigBody.safety_settings;
     const model = this.model.replace(/^(?:gemini|google)\//, "");
     const baseUrl = this.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
-    const requestInit = {
+    const buildRequestInit = (currentContents) => ({
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        contents,
+        contents: currentContents,
         ...Object.keys(generationConfigBody).length > 0 ? { generationConfig: generationConfigBody } : {},
         ..."system_instruction" in requestBody ? { system_instruction: requestBody.system_instruction } : {},
         ..."tools" in requestBody ? { tools: requestBody.tools } : {},
         ..."safety_settings" in requestBody ? { safety_settings: requestBody.safety_settings } : {}
-      })
-    };
-    if (options?.signal) {
-      requestInit.signal = options.signal;
-    }
-    return fetch(
-      `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(apiKey)}`,
-      requestInit
-    ).then(async (response) => {
+      }),
+      ...options?.signal ? { signal: options.signal } : {}
+    });
+    const generateContent = async (currentContents) => {
+      const response = await fetch(
+        `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(apiKey)}`,
+        buildRequestInit(currentContents)
+      );
       const body = await response.json();
       if (!response.ok) {
         const error = readObject2(readObject2(body).error);
         throw new Error(scalarToString(error.message) ?? `Gemini request failed with HTTP ${response.status.toString()}.`);
       }
+      return body;
+    };
+    return generateContent(contents).then(async (body) => {
       return await this.processResponseWithTools(
         body,
         contents,
-        options?.availableFunctions ?? options?.available_functions ?? null
+        options?.availableFunctions ?? options?.available_functions ?? null,
+        generateContent,
+        geminiMaxToolRounds(options)
       );
     });
   }
@@ -47673,42 +47678,69 @@ ${textContent}` : textContent;
   static extract_structured_output_from_response(response) {
     return _GeminiCompletion.extractStructuredOutputFromResponse(response);
   }
-  async processResponseWithTools(response, contents = [], availableFunctions = null) {
-    void contents;
-    const candidates = readObject2(response).candidates;
-    if (!Array.isArray(candidates)) {
-      return _GeminiCompletion.extractTextFromResponse(response);
-    }
-    const first = readObject2(candidates[0]);
-    const rawParts = Array.isArray(readObject2(first.content).parts) ? readObject2(first.content).parts : [];
-    const functionCallParts = rawParts.filter((part) => Object.keys(readObject2(readObject2(part).functionCall ?? readObject2(part).function_call)).length > 0);
-    const nonStructuredParts = functionCallParts.filter((part) => {
-      const partRecord = readObject2(part);
-      const functionCall = readObject2(partRecord.functionCall ?? partRecord.function_call);
-      return (scalarToString(functionCall.name) ?? "") !== STRUCTURED_OUTPUT_TOOL_NAME;
-    });
-    if (nonStructuredParts.length > 0 && !availableFunctions) {
-      return nonStructuredParts;
-    }
-    if (nonStructuredParts.length > 0 && availableFunctions) {
+  async processResponseWithTools(response, contents = [], availableFunctions = null, generateContent = null, maxToolRounds = DEFAULT_GEMINI_MAX_TOOL_ROUNDS) {
+    let currentResponse = response;
+    let currentContents = [...contents];
+    for (let round = 0; round <= maxToolRounds; round += 1) {
+      const candidates = readObject2(currentResponse).candidates;
+      if (!Array.isArray(candidates)) {
+        return _GeminiCompletion.extractTextFromResponse(currentResponse);
+      }
+      const first = readObject2(candidates[0]);
+      const rawParts = Array.isArray(readObject2(first.content).parts) ? readObject2(first.content).parts : [];
+      const functionCallParts = rawParts.filter((part) => Object.keys(readObject2(readObject2(part).functionCall ?? readObject2(part).function_call)).length > 0);
+      const structuredOutput = _GeminiCompletion.extractStructuredOutputFromResponse(currentResponse);
+      const nonStructuredParts = functionCallParts.filter((part) => {
+        const partRecord = readObject2(part);
+        const functionCall = readObject2(partRecord.functionCall ?? partRecord.function_call);
+        return (scalarToString(functionCall.name) ?? "") !== STRUCTURED_OUTPUT_TOOL_NAME;
+      });
+      if (nonStructuredParts.length === 0) {
+        return structuredOutput ?? _GeminiCompletion.extractTextFromResponse(currentResponse);
+      }
+      if (!availableFunctions) {
+        return nonStructuredParts;
+      }
+      if (round >= maxToolRounds) {
+        throw new Error(`Gemini tool loop exceeded max tool rounds (${String(maxToolRounds)}).`);
+      }
+      const functionResponseParts = [];
+      let firstToolResult = null;
       for (const part of nonStructuredParts) {
         const partRecord = readObject2(part);
         const functionCall = readObject2(partRecord.functionCall ?? partRecord.function_call);
-        const functionName = scalarToString(functionCall.name);
+        const rawFunctionName = scalarToString(functionCall.name) ?? "";
+        const functionName = resolveGeminiFunctionName(rawFunctionName, availableFunctions);
         if (!functionName) {
-          continue;
+          throw new Error(`Gemini requested unknown function '${rawFunctionName}'.`);
         }
         const result = await this.handleToolExecution({
           functionName,
           functionArgs: readObject2(functionCall.args),
           availableFunctions
         });
-        if (result !== null) {
-          return result;
+        if (result === null) {
+          throw new Error(`Gemini failed to execute function '${rawFunctionName}'.`);
         }
+        firstToolResult ??= result;
+        functionResponseParts.push({
+          functionResponse: {
+            name: rawFunctionName,
+            response: { result }
+          }
+        });
       }
+      if (!generateContent) {
+        return firstToolResult;
+      }
+      currentContents = [
+        ...currentContents,
+        { role: "model", parts: rawParts },
+        { role: "user", parts: functionResponseParts }
+      ];
+      currentResponse = await generateContent(currentContents);
     }
-    return _GeminiCompletion.extractTextFromResponse(response);
+    throw new Error(`Gemini tool loop exceeded max tool rounds (${String(maxToolRounds)}).`);
   }
   async _process_response_with_tools(response, contents = [], availableFunctions = null) {
     return await this.processResponseWithTools(response, contents, availableFunctions);
@@ -48797,6 +48829,19 @@ function geminiVersion(model) {
   const match = /gemini-(\d+(?:\.\d+)?)/iu.exec(model.toLowerCase());
   return match ? Number.parseFloat(match[1] ?? "0") : 0;
 }
+var DEFAULT_GEMINI_MAX_TOOL_ROUNDS = 8;
+function geminiMaxToolRounds(options) {
+  const record = readObject2(options);
+  const configured = record.maxToolRounds ?? record.max_tool_rounds;
+  return typeof configured === "number" && Number.isInteger(configured) && configured > 0 ? configured : DEFAULT_GEMINI_MAX_TOOL_ROUNDS;
+}
+function resolveGeminiFunctionName(functionName, availableFunctions) {
+  if (functionName in availableFunctions) {
+    return functionName;
+  }
+  const sanitizedName = sanitizeToolName(functionName);
+  return sanitizedName in availableFunctions ? sanitizedName : null;
+}
 function geminiTextParts(content) {
   if (Array.isArray(content)) {
     return content.map((item) => {
@@ -52088,9 +52133,11 @@ ${todo.description}`);
     if (this.tools.length === 0) {
       return Object.keys(options).length > 0 ? options : void 0;
     }
-    const [tools] = setupNativeTools(this.tools);
+    const [tools, availableFunctions] = setupNativeTools(this.tools);
     if (tools.length > 0) {
       options.tools = tools;
+      options.availableFunctions = availableFunctions;
+      options.available_functions = availableFunctions;
     }
     return Object.keys(options).length > 0 ? options : void 0;
   }