@tanstack/ai/dist/esm/activities/chat/agents/bound.js

Type-safe TypeScript AI SDK for streaming chat, tool calling, agents, structured outputs, and multimodal generation.

import { summarize } from "../../summarize/index.js";
import { generateImage } from "../../generateImage/index.js";
import { generateVideo } from "../../generateVideo/index.js";
import { generateAudio } from "../../generateAudio/index.js";
import { generateSpeech } from "../../generateSpeech/index.js";
import { generateVoice } from "../../generateVoice/index.js";
import { generateTranscription } from "../../generateTranscription/index.js";
import { generateWorld } from "../../generateWorld/index.js";
import { generateLiveVideo } from "../../generateLiveVideo/index.js";
import { embed } from "../../embed/index.js";
import { rerank } from "../../rerank/index.js";
import { decide } from "../../evaluate/index.js";
import { chat } from "../index.js";
//#region src/activities/chat/agents/bound.ts
/**
* The host definitions, then the call's own. The call's own definitions win:
* a host definition with the same id is left out.
*/
function mergeInterrupts(host, own) {
	const ids = new Set((own ?? []).map((definition) => definition.id));
	return [...host.filter((definition) => !ids.has(definition.id)), ...own ?? []];
}
function createBoundActivities(agentName, input, abortController, binding) {
	let calls = 0;
	let chatCalls = 0;
	const signal = abortController.signal;
	const chatMiddleware = binding?.chatMiddleware ?? [];
	const lastChatMiddleware = binding?.lastChatMiddleware ?? [];
	const generationMiddleware = binding?.generationMiddleware ?? [];
	const interrupts = binding?.interrupts ?? [];
	const ids = (activity) => {
		calls += 1;
		return {
			threadId: input.threadId,
			runId: `${input.runId}:${activity}-${calls}`
		};
	};
	const withHost = (options) => ({
		...options,
		debug: options.debug ?? binding?.debug,
		middleware: [...generationMiddleware, ...options.middleware ?? []]
	});
	const full = (activity, options) => withHost({
		...ids(activity),
		abortSignal: signal,
		...options
	});
	return {
		chat: ((options) => chat({
			messages: input.messages,
			threadId: input.threadId,
			runId: chatCalls++ === 0 ? input.runId : `${input.runId}:chat-${chatCalls}`,
			parentRunId: input.parentRunId,
			subagentRunId: input.subagentRunId,
			subagentName: agentName,
			parentSubagentRunId: input.parentSubagentRunId,
			...input.resume ? { resume: input.resume } : {},
			...binding?.promptCache ? { promptCache: binding.promptCache } : {},
			abortController,
			...options,
			debug: options.debug ?? binding?.debug,
			...options.subagents ? { subagents: {
				...options.subagents,
				binding: {
					...binding?.keys ? { keys: binding.keys } : {},
					...binding?.debug !== void 0 ? { debug: binding.debug } : {},
					...options.subagents.binding,
					chatMiddleware: [...chatMiddleware, ...options.subagents.binding?.chatMiddleware ?? []],
					lastChatMiddleware: [...options.subagents.binding?.lastChatMiddleware ?? [], ...lastChatMiddleware],
					generationMiddleware: [...generationMiddleware, ...options.subagents.binding?.generationMiddleware ?? []],
					...interrupts.length > 0 ? { interrupts: mergeInterrupts(interrupts, options.subagents.binding?.interrupts) } : {},
					...binding?.budget ? { budget: binding.budget } : {},
					...binding?.extend ? { extend: binding.extend } : {}
				}
			} } : {},
			...interrupts.length > 0 ? { interrupts: mergeInterrupts(interrupts, options.interrupts) } : {},
			middleware: [
				...chatMiddleware,
				...options.middleware ?? [],
				...lastChatMiddleware
			]
		})),
		summarize: ((options) => summarize(full("summarize", options))),
		generateImage: ((options) => generateImage(full("image", options))),
		generateVideo: ((options) => generateVideo(full("video", options))),
		generateAudio: ((options) => generateAudio(full("audio", options))),
		generateSpeech: ((options) => generateSpeech(full("speech", options))),
		generateVoice: ((options) => generateVoice(full("voice", options))),
		generateTranscription: ((options) => generateTranscription(full("transcription", options))),
		generateWorld: ((options) => generateWorld(full("world", options))),
		generateLiveVideo: ((options) => generateLiveVideo(full("liveVideo", options))),
		embed: ((options) => embed(withHost(options))),
		rerank: ((options) => rerank(withHost({
			abortSignal: signal,
			...options
		}))),
		decide: ((options) => decide(withHost({
			abortSignal: signal,
			...options
		})))
	};
}
//#endregion
export { createBoundActivities };

//# sourceMappingURL=bound.js.map