Skip to content
tRPC

AI SDK

Stream useChat responses from a procedure, and give procedures to the model as tools.

On this page

AI SDK (v7) streams chat responses as a ReadableStream of UI message chunks. A procedure returns that stream as it is, and the client gets a ReadableStream back, which is what useChat's transport returns. This needs no adapter package, and it's tested against the real library in test/integration/.

import {
  
function convertToModelMessages<UI_MESSAGE extends UIMessage>(messages: Array<Omit<UI_MESSAGE, "id">>, options?: {
    tools?: ToolSet;
    ignoreIncompleteToolCalls?: boolean;
    convertDataPart?: (part: DataUIPart<InferUIMessageData<UI_MESSAGE>>) => TextPart | FilePart | undefined;
}): Promise<ModelMessage[]>
convertToModelMessages,
  
function streamText<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends Output = Output<string, string, never>>({ model, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries, streamRetries, abortSignal, timeout, headers, stopWhen, experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry, prepareStep, providerOptions, activeTools, toolOrder, experimental_repairToolCall, repairToolCall, experimental_refineToolInput: refineToolInput, experimental_transform: transform, experimental_download: download, includeRawChunks, onChunk, onError: onErrorArg, onFinish, onEnd, onAbort, onStepEnd, onStepFinish, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, runtimeContext, toolsContext, experimental_include, include, _internal: { now, generateId, generateCallId }, ...settings }: LanguageModelCallOptions & RequestOptions<TOOLS> & Prompt & ToolsContextParameter<TOOLS> & {
    model: LanguageModel;
    toolChoice?: ToolChoice<TOOLS>;
    stopWhen?: Arrayable<StopCondition<NoInfer<TOOLS>, RUNTIME_CONTEXT>>;
    telemetry?: TelemetryOptions<RUNTIME_CONTEXT, NoInfer<TOOLS>>;
    experimental_telemetry?: TelemetryOptions<RUNTIME_CONTEXT, NoInfer<TOOLS>>;
    providerOptions?: ProviderOptions;
    experimental_sandbox?: SandboxSession;
    runtimeContext?: RUNTIME_CONTEXT;
    activeTools?: ActiveTools<NoInfer<TOOLS>>;
    toolOrder?: ToolOrder<NoInfer<TOOLS>>;
    output?: OUTPUT;
    toolApproval?: ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT>;
    experimental_toolCallers?: Experimental_ToolCallers<NoInfer<TOOLS>>;
    experimental_toolApprovalSecret?: string | Uint8Array;
    prepareStep?: PrepareStepFunction<NoInfer<TOOLS>, RUNTIME_CONTEXT>;
    repairToolCall?: ToolCallRepairFunction<TOOLS>;
    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
    experimental_refineToolInput?: ToolInputRefinement<NoInfer<TOOLS>>;
    experimental_transform?: Arrayable<StreamTextTransform<TOOLS>>;
    experimental_download?: DownloadFunction | undefined;
    includeRawChunks?: boolean;
    onChunk?: StreamTextOnChunkCallback<TOOLS>;
    onError?: StreamTextOnErrorCallback | StreamTextOnErrorRetryCallback | StreamTextOnErrorHandler;
    streamRetries?: number;
    onEnd?: StreamTextOnEndCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    onFinish?: StreamTextOnEndCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    onAbort?: StreamTextOnAbortCallback<...>;
    onStepEnd?: GenerateTextOnStepEndCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>>;
    onStepFinish?: GenerateTextOnStepFinishCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>>;
    onStart?: GenerateTextOnStartCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    experimental_onStart?: GenerateTextOnStartCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    onStepStart?: GenerateTextOnStepStartCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    experimental_onStepStart?: GenerateTextOnStepStartCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
    experimental_onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
    onLanguageModelCallEnd?: OnLanguageModelCallEndCallback<NoInfer<TOOLS>>;
    experimental_onLanguageModelCallEnd?: OnLanguageModelCallEndCallback<NoInfer<TOOLS>>;
    onToolExecutionStart?: OnToolExecutionStartCallback<NoInfer<TOOLS>>;
    experimental_onToolCallStart?: OnToolExecutionStartCallback<NoInfer<TOOLS>>;
    onToolExecutionEnd?: OnToolExecutionEndCallback<NoInfer<TOOLS>>;
    experimental_onToolCallFinish?: OnToolExecutionEndCallback<NoInfer<TOOLS>>;
    include?: StreamTextInclude;
    experimental_include?: StreamTextInclude;
    _internal?: {
        now?: () => number;
        generateId?: IdGenerator;
        generateCallId?: IdGenerator;
    };
}): StreamTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>
streamText,
  
function toUIMessageStream<TOOLS extends ToolSet = ToolSet, UI_MESSAGE extends UIMessage = UIMessage<unknown, UIDataTypes, UITools>>({ stream, tools, sendReasoning, sendSources, sendStart, sendFinish, onError, messageMetadata, originalMessages, generateMessageId, onStepEnd, onStepFinish, onEnd, onFinish }: {
    stream: ReadableStream<TextStreamPart<TOOLS>>;
    tools?: TOOLS;
} & UIMessageStreamOptions<UI_MESSAGE>): ReadableStream<InferUIMessageChunk<UI_MESSAGE>>
toUIMessageStream,
  type interface UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools>UIMessage,
} from 'ai';

const 
const router: {
    chat: BuildProcedure<InputDef<RootDef<Context, {}>, z.ZodObject<{
        chatId: z.ZodString;
        messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
    }, z.core.$strip>>, "mutation", {
        output: ReadableStream<InferUIMessageChunk<UIMessage<unknown, UIDataTypes, UITools>>>;
        errors: never;
        services: never;
        unmapped: never;
    }>;
}
router = {
  
chat: BuildProcedure<InputDef<RootDef<Context, {}>, z.ZodObject<{
    chatId: z.ZodString;
    messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
}, z.core.$strip>>, "mutation", {
    output: ReadableStream<InferUIMessageChunk<UIMessage<unknown, UIDataTypes, UITools>>>;
    errors: never;
    services: never;
    unmapped: never;
}>
chat: const t: TrpcRoot<Context, {}, RootDef<Context, {}>>t.TrpcRoot<Context, {}, RootDef<Context, {}>>.procedure: ProcedureBuilder<RootDef<Context, {}>>procedure
    .
ProcedureBuilder<RootDef<Context, {}>>.input<z.ZodObject<{
    chatId: z.ZodString;
    messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
}, z.core.$strip>>(schema: z.ZodObject<{
    chatId: z.ZodString;
    messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
}, z.core.$strip>): ProcedureBuilder<InputDef<RootDef<Context, {}>, z.ZodObject<...>>> (+1 overload)
input(
      import zz.
function object<{
    chatId: z.ZodString;
    messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
}>(shape?: {
    chatId: z.ZodString;
    messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueUnrecognizedKeys | z.core.$ZodIssueInvalidType<unknown>>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<...>
object({
        chatId: z.ZodStringchatId: import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string(),
        messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>messages: import zz.function array<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>(element: z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>, params?: string | z.core.$ZodArrayParams): z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>array(import zz.
function custom<UIMessage<unknown, UIDataTypes, UITools>>(fn?: (data: unknown) => unknown, _params?: string | {
    path?: PropertyKey[] | undefined | undefined;
    params?: Record<string, any> | undefined;
    abort?: boolean | undefined | undefined;
    when?: ((payload: z.core.ParsePayload) => boolean) | undefined | undefined;
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssue>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<...>>
custom<interface UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools>UIMessage>()),
      }),
    )
    .
ProcedureBuilder<InputDef<RootDef<Context, {}>, ZodObject<{ chatId: ZodString; messages: ZodArray<ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<...>>>; }, $strip>>>.mutation<Promise<ReadableStream<InferUIMessageChunk<UIMessage<unknown, UIDataTypes, UITools>>>>>(resolver: (opts: ResolverOpts<InputDef<RootDef<Context, {}>, z.ZodObject<{
    chatId: z.ZodString;
    messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
}, z.core.$strip>>>) => Promise<ReadableStream<InferUIMessageChunk<UIMessage<unknown, UIDataTypes, UITools>>>>): BuildProcedure<...>
mutation(async (
opts: ResolverOpts<InputDef<RootDef<Context, {}>, z.ZodObject<{
    chatId: z.ZodString;
    messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
}, z.core.$strip>>>
opts) => {
      const const result: StreamTextResult<ToolSet, Context, Output<string, string, never>>result = 
streamText<ToolSet, Context, Output<string, string, never>>({ model, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries, streamRetries, abortSignal, timeout, headers, stopWhen, experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry, prepareStep, providerOptions, activeTools, toolOrder, experimental_repairToolCall, repairToolCall, experimental_refineToolInput: refineToolInput, experimental_transform: transform, experimental_download: download, includeRawChunks, onChunk, onError: onErrorArg, onFinish, onEnd, onAbort, onStepEnd, onStepFinish, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, runtimeContext, toolsContext, experimental_include, include, _internal: { now, generateId, generateCallId }, ...settings }: ((LanguageModelCallOptions & (RequestOptions<ToolSet> & Prompt)) & {
    tools?: ToolSet | undefined;
}) & {
    toolsContext?: never;
} & {
    model: LanguageModel;
    toolChoice?: ToolChoice<ToolSet> | undefined;
    stopWhen?: Arrayable<StopCondition<NoInfer<ToolSet>, Context>>;
    telemetry?: TelemetryOptions<Context, NoInfer<ToolSet>> | undefined;
    ... 39 more ...;
    _internal?: {
        now?: () => number;
        generateId?: IdGenerator;
        generateCallId?: IdGenerator;
    };
}): StreamTextResult<...>
streamText({
        model: LanguageModelmodel,
        messages: ModelMessage[]messages: await 
convertToModelMessages<UIMessage<unknown, UIDataTypes, UITools>>(messages: Omit<UIMessage<unknown, UIDataTypes, UITools>, "id">[], options?: {
    tools?: ToolSet;
    ignoreIncompleteToolCalls?: boolean;
    convertDataPart?: ((part: {
        type: `data-${string}`;
        id?: string;
        data: unknown;
    }) => TextPart | FilePart | undefined) | undefined;
} | undefined): Promise<ModelMessage[]>
convertToModelMessages(
opts: ResolverOpts<InputDef<RootDef<Context, {}>, z.ZodObject<{
    chatId: z.ZodString;
    messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
}, z.core.$strip>>>
opts.
ResolverOpts<InputDef<RootDef<Context, {}>, ZodObject<{ chatId: ZodString; messages: ZodArray<ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<...>>>; }, $strip>>>.input: {
    chatId: string;
    messages: UIMessage<unknown, UIDataTypes, UITools>[];
}
input.messages: UIMessage<unknown, UIDataTypes, UITools>[]messages),
        abortSignal?: AbortSignal | undefinedabortSignal: 
opts: ResolverOpts<InputDef<RootDef<Context, {}>, z.ZodObject<{
    chatId: z.ZodString;
    messages: z.ZodArray<z.ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<unknown, UIDataTypes, UITools>>>;
}, z.core.$strip>>>
opts.ResolverOpts<InputDef<RootDef<Context, {}>, ZodObject<{ chatId: ZodString; messages: ZodArray<ZodCustom<UIMessage<unknown, UIDataTypes, UITools>, UIMessage<...>>>; }, $strip>>>.signal: AbortSignalsignal,
      });
      return 
toUIMessageStream<ToolSet, UIMessage<unknown, UIDataTypes, UITools>>({ stream, tools, sendReasoning, sendSources, sendStart, sendFinish, onError, messageMetadata, originalMessages, generateMessageId, onStepEnd, onStepFinish, onEnd, onFinish }: {
    stream: ReadableStream<TextStreamPart<ToolSet>>;
    tools?: ToolSet | undefined;
} & UIMessageStreamOptions<UIMessage<unknown, UIDataTypes, UITools>>): ReadableStream<InferUIMessageChunk<UIMessage<unknown, UIDataTypes, UITools>>>
toUIMessageStream({ stream: ReadableStream<TextStreamPart<ToolSet>>stream: const result: StreamTextResult<ToolSet, Context, Output<string, string, never>>result.StreamTextResult<ToolSet, Context, Output<string, string, never>>.stream: AsyncIterableStream<TextStreamPart<ToolSet>>stream });
    }),
};
import { useChat } from '@ai-sdk/react';

const chat = useChat({
  transport: {
    sendMessages: (opts) =>
      client.chat.mutate(
        { chatId: opts.chatId, messages: opts.messages },
        { signal: opts.abortSignal },
      ),
    reconnectToStream: async () => null,
  },
});
  • The chunks stream as JSONL (or binary frames) and arrive as plain objects, so AI SDK's structuredClone works on them.
  • Stopping the chat aborts the call; signal reaches streamText, which stops the model.
  • reconnectToStream returning null means "nothing to resume". For resumable chats, keep the stream behind a Publisher channel and return a subscription to it.

Procedures as tools

AI SDK takes Standard Schema as a tool's inputSchema, so a tool reuses the procedure's input schema and runs the procedure with call(), middleware and validation included:

import { 
function generateText<TOOLS extends ToolSet, RUNTIME_CONTEXT extends Context = Context, OUTPUT extends Output = Output<string, string, any>>({ model: modelArg, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries: maxRetriesArg, abortSignal, timeout, headers, stopWhen, experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry, providerOptions, activeTools, toolOrder, prepareStep, experimental_repairToolCall, repairToolCall, experimental_refineToolInput: refineToolInput, experimental_download: download, runtimeContext, toolsContext, experimental_include, include, _internal: { generateId, generateCallId, now }, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, onStepEnd, onStepFinish, onFinish, onEnd, ...settings }: LanguageModelCallOptions & RequestOptions<TOOLS> & Prompt & ToolsContextParameter<TOOLS> & {
    model: LanguageModel;
    toolChoice?: ToolChoice<NoInfer<TOOLS>>;
    stopWhen?: Arrayable<StopCondition<NoInfer<TOOLS>, RUNTIME_CONTEXT>>;
    telemetry?: TelemetryOptions<RUNTIME_CONTEXT, NoInfer<TOOLS>>;
    experimental_telemetry?: TelemetryOptions<RUNTIME_CONTEXT, NoInfer<TOOLS>>;
    providerOptions?: ProviderOptions;
    experimental_sandbox?: SandboxSession;
    runtimeContext?: RUNTIME_CONTEXT;
    activeTools?: ActiveTools<NoInfer<TOOLS>>;
    toolOrder?: ToolOrder<NoInfer<TOOLS>>;
    output?: OUTPUT;
    toolApproval?: ToolApprovalConfiguration<TOOLS, RUNTIME_CONTEXT>;
    experimental_toolCallers?: Experimental_ToolCallers<NoInfer<TOOLS>>;
    experimental_toolApprovalSecret?: string | Uint8Array;
    experimental_download?: DownloadFunction | undefined;
    prepareStep?: PrepareStepFunction<NoInfer<TOOLS>, RUNTIME_CONTEXT>;
    repairToolCall?: ToolCallRepairFunction<NoInfer<TOOLS>>;
    experimental_repairToolCall?: ToolCallRepairFunction<NoInfer<TOOLS>>;
    experimental_refineToolInput?: ToolInputRefinement<NoInfer<TOOLS>>;
    onStart?: GenerateTextOnStartCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    experimental_onStart?: GenerateTextOnStartCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    onStepStart?: GenerateTextOnStepStartCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    experimental_onStepStart?: GenerateTextOnStepStartCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>, NoInfer<OUTPUT>>;
    onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
    experimental_onLanguageModelCallStart?: OnLanguageModelCallStartCallback;
    onLanguageModelCallEnd?: OnLanguageModelCallEndCallback<NoInfer<TOOLS>>;
    experimental_onLanguageModelCallEnd?: OnLanguageModelCallEndCallback<NoInfer<TOOLS>>;
    onToolExecutionStart?: OnToolExecutionStartCallback<NoInfer<TOOLS>>;
    experimental_onToolCallStart?: OnToolExecutionStartCallback<NoInfer<TOOLS>>;
    onToolExecutionEnd?: OnToolExecutionEndCallback<NoInfer<TOOLS>>;
    experimental_onToolCallFinish?: OnToolExecutionEndCallback<NoInfer<TOOLS>>;
    onStepEnd?: GenerateTextOnStepEndCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>>;
    onStepFinish?: GenerateTextOnStepFinishCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>>;
    onEnd?: GenerateTextOnEndCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>>;
    onFinish?: GenerateTextOnEndCallback<NoInfer<TOOLS>, NoInfer<RUNTIME_CONTEXT>>;
    include?: GenerateTextInclude;
    experimental_include?: GenerateTextInclude;
    _internal?: {
        generateId?: IdGenerator;
        generateCallId?: IdGenerator;
        now?: () => number;
    };
}): Promise<GenerateTextResult<TOOLS, RUNTIME_CONTEXT, OUTPUT>>
generateText, 
function tool<INPUT, OUTPUT, CONTEXT extends Context>(tool: Tool<INPUT, OUTPUT, CONTEXT> & {
    execute: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
}): ExecutableTool<Tool<INPUT, OUTPUT, CONTEXT>> (+4 overloads)
tool } from 'ai';
import { function call<TDef extends ProcedureDef>(procedure: Procedure<TDef>, input: TDef["input"], opts: CallOptions<TDef>): Promise<TDef["output"]>call } from '@trpc12/trpc/server';

const 
const WeatherInput: z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>
WeatherInput = import zz.
function object<{
    city: z.ZodString;
}>(shape?: {
    city: z.ZodString;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueInvalidType<unknown> | z.core.$ZodIssueUnrecognizedKeys>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>
object({ city: z.ZodStringcity: import zz.function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string() });
const 
const weatherProcedure: BuildProcedure<InputDef<RootDef<Context, {}>, z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>>, "query", {
    output: string;
    errors: never;
    services: never;
    unmapped: never;
}>
weatherProcedure = const t: TrpcRoot<Context, {}, RootDef<Context, {}>>t.TrpcRoot<Context, {}, RootDef<Context, {}>>.procedure: ProcedureBuilder<RootDef<Context, {}>>procedure
  .
ProcedureBuilder<RootDef<Context, {}>>.input<z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>>(schema: z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>): ProcedureBuilder<InputDef<RootDef<Context, {}>, z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>>> (+1 overload)
input(
const WeatherInput: z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>
WeatherInput)
  .
ProcedureBuilder<InputDef<RootDef<Context, {}>, ZodObject<{ city: ZodString; }, $strip>>>.query<Promise<string>>(resolver: (opts: ResolverOpts<InputDef<RootDef<Context, {}>, z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>>>) => Promise<string>): BuildProcedure<InputDef<RootDef<Context, {}>, z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>>, "query", {
    output: string;
    errors: never;
    services: never;
    unmapped: never;
}>
query((
opts: ResolverOpts<InputDef<RootDef<Context, {}>, z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>>>
opts) => function forecast(city: string): Promise<string>forecast(
opts: ResolverOpts<InputDef<RootDef<Context, {}>, z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>>>
opts.
ResolverOpts<InputDef<RootDef<Context, {}>, ZodObject<{ city: ZodString; }, $strip>>>.input: {
    city: string;
}
input.city: stringcity));

const 
const weather: ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & {
    ...;
} & {
    ...;
} & {
    ...;
} & {
    ...;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
})
weather = 
tool<{
    city: string;
}, string, Context>(tool: ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & {
    ...;
} & {
    ...;
} & {
    ...;
} & {
    ...;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
})): ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
}) | ... 2 more ... | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => ... (+4 overloads)
tool({
  
description?: string | ((options: {
    context: NoInfer<Context>;
    experimental_sandbox?: SandboxSession;
}) => string) | undefined
description: 'The weather in a city',
  
inputSchema: FlexibleSchema<{
    city: string;
}>
inputSchema: 
const WeatherInput: z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>
WeatherInput,
  
execute: (input: {
    city: string;
}) => Promise<string>
execute: (
input: {
    city: string;
}
input) => 
call<{
    type: "query";
    ctx: Context;
    meta: {};
    input: {
        city: string;
    };
    output: string;
    errors: InputValidationError<{
        readonly code: "unrecognized_keys";
        readonly keys: readonly string[];
        readonly path: readonly [] | readonly ["city"];
        readonly message: string;
    } | {
        readonly code: "invalid_type";
        readonly expected: z.core.$ZodInvalidTypeExpected;
        readonly path: readonly [] | readonly ["city"];
        readonly message: string;
    } | {
        readonly code: "too_big";
        readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
        readonly maximum: string | number;
        readonly inclusive?: boolean | undefined;
        readonly exact?: boolean | undefined;
        readonly path: readonly [] | readonly [...];
        readonly message: string;
    } | ... 8 more ... | {
        ...;
    }>;
    services: never;
}>(procedure: Procedure<...>, input: {
    ...;
}, opts: CallOptions<...>): Promise<...>
call(
const weatherProcedure: BuildProcedure<InputDef<RootDef<Context, {}>, z.ZodObject<{
    city: z.ZodString;
}, z.core.$strip>>, "query", {
    output: string;
    errors: never;
    services: never;
    unmapped: never;
}>
weatherProcedure, 
input: {
    city: string;
}
input, { ctx: Contextctx }),
});

await 
generateText<{
    weather: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: ProviderOptions;
        metadata?: JSONObject;
        inputSchema: FlexibleSchema<{
            city: string;
        }>;
        contextSchema?: FlexibleSchema<Context> | undefined;
        needsApproval?: boolean | ToolNeedsApprovalFunction<{
            city: string;
        }, NoInfer<Context>> | undefined;
        onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            ...;
        }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
    } & {
        ...;
    } & {
        ...;
    } & {
        ...;
    } & {
        ...;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: ProviderOptions;
        metadata?: JSONObject;
        inputSchema: FlexibleSchema<{
            city: string;
        }>;
        contextSchema?: FlexibleSchema<Context> | undefined;
        needsApproval?: boolean | ToolNeedsApprovalFunction<{
            city: string;
        }, NoInfer<Context>> | undefined;
        onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            ...;
        }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
    } & ... 3 more ... & {
        ...;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: ProviderOptions;
        metadata?: JSONObject;
        inputSchema: FlexibleSchema<{
            city: string;
        }>;
        contextSchema?: FlexibleSchema<Context> | undefined;
        needsApproval?: boolean | ToolNeedsApprovalFunction<{
            city: string;
        }, NoInfer<Context>> | undefined;
        onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            ...;
        }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
    } & ... 3 more ... & {
        ...;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: ProviderOptions;
        metadata?: JSONObject;
        inputSchema: FlexibleSchema<{
            city: string;
        }>;
        contextSchema?: FlexibleSchema<Context> | undefined;
        needsApproval?: boolean | ToolNeedsApprovalFunction<{
            city: string;
        }, NoInfer<Context>> | undefined;
        onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            ...;
        }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
    } & ... 3 more ... & {
        ...;
    });
}, Context, Output<...>>({ model: modelArg, tools, toolChoice, instructions, system, prompt, messages, allowSystemInMessages, maxRetries: maxRetriesArg, abortSignal, timeout, headers, stopWhen, experimental_sandbox: sandbox, output, toolApproval, experimental_toolCallers, experimental_toolApprovalSecret, experimental_telemetry, telemetry, providerOptions, activeTools, toolOrder, prepareStep, experimental_repairToolCall, repairToolCall, experimental_refineToolInput: refineToolInput, experimental_download: download, runtimeContext, toolsContext, experimental_include, include, _internal: { generateId, generateCallId, now }, onStart, experimental_onStart, onStepStart, experimental_onStepStart, onLanguageModelCallStart, experimental_onLanguageModelCallStart, onLanguageModelCallEnd, experimental_onLanguageModelCallEnd, onToolExecutionStart, onToolExecutionEnd, experimental_onToolCallStart, experimental_onToolCallFinish, onStepEnd, onStepFinish, onFinish, onEnd, ...settings }: ((LanguageModelCallOptions & (RequestOptions<...> & Prompt)) & {
    ...;
}) ...
generateText({ model: LanguageModelmodel, 
tools?: {
    weather: ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: ProviderOptions;
        metadata?: JSONObject;
        inputSchema: FlexibleSchema<{
            city: string;
        }>;
        contextSchema?: FlexibleSchema<Context> | undefined;
        needsApproval?: boolean | ToolNeedsApprovalFunction<{
            city: string;
        }, NoInfer<Context>> | undefined;
        onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            ...;
        }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
    } & {
        ...;
    } & {
        ...;
    } & {
        ...;
    } & {
        ...;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: ProviderOptions;
        metadata?: JSONObject;
        inputSchema: FlexibleSchema<{
            city: string;
        }>;
        contextSchema?: FlexibleSchema<Context> | undefined;
        needsApproval?: boolean | ToolNeedsApprovalFunction<{
            city: string;
        }, NoInfer<Context>> | undefined;
        onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            ...;
        }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
    } & ... 3 more ... & {
        ...;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: ProviderOptions;
        metadata?: JSONObject;
        inputSchema: FlexibleSchema<{
            city: string;
        }>;
        contextSchema?: FlexibleSchema<Context> | undefined;
        needsApproval?: boolean | ToolNeedsApprovalFunction<{
            city: string;
        }, NoInfer<Context>> | undefined;
        onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            ...;
        }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
    } & ... 3 more ... & {
        ...;
    }) | ({
        deferLoading?: boolean;
        title?: string;
        providerOptions?: ProviderOptions;
        metadata?: JSONObject;
        inputSchema: FlexibleSchema<{
            city: string;
        }>;
        contextSchema?: FlexibleSchema<Context> | undefined;
        needsApproval?: boolean | ToolNeedsApprovalFunction<{
            city: string;
        }, NoInfer<Context>> | undefined;
        onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
        onInputDelta?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        onInputAvailable?: ((options: {
            ...;
        } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
        toModelOutput?: ((options: {
            ...;
        }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
    } & ... 3 more ... & {
        ...;
    });
} | undefined
tools: { 
weather: ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & {
    ...;
} & {
    ...;
} & {
    ...;
} & {
    ...;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
}) | ({
    deferLoading?: boolean;
    title?: string;
    providerOptions?: ProviderOptions;
    metadata?: JSONObject;
    inputSchema: FlexibleSchema<{
        city: string;
    }>;
    contextSchema?: FlexibleSchema<Context> | undefined;
    needsApproval?: boolean | ToolNeedsApprovalFunction<{
        city: string;
    }, NoInfer<Context>> | undefined;
    onInputStart?: ((options: ToolExecutionOptions<NoInfer<Context>>) => void | PromiseLike<void>) | undefined;
    onInputDelta?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    onInputAvailable?: ((options: {
        ...;
    } & ToolExecutionOptions<...>) => void | PromiseLike<void>) | undefined;
    toModelOutput?: ((options: {
        ...;
    }) => ToolResultOutput | PromiseLike<ToolResultOutput>) | undefined;
} & ... 3 more ... & {
    ...;
})
weather }, prompt: string | ModelMessage[]prompt });