flamecast 0.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @smithery/act-sdk@0.1.0 build /Users/anirudh/conductor/workspaces/act-sdk/rabat/packages/act-sdk
+> tsc
+

package/README.md

@@ -0,0 +1,15 @@
+# runner-example
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.1.10. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "flamecast",
+	"version": "0.0.1",
+	"type": "module",
+	"publishConfig": {
+		"access": "public"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"build": "tsc",
+		"check-types": "tsc --noEmit",
+		"check": "biome check",
+		"fmt": "biome check --write --unsafe"
+	},
+	"devDependencies": {
+		"@types/node": "latest",
+		"tsx": "^4.21.0",
+		"@smithery/typescript-config": "workspace:*"
+	},
+	"peerDependencies": {
+		"typescript": "^5.0.0"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.25.2",
+		"@smithery/runner": "workspace:*",
+		"ai": "^6.0.3",
+		"dotenv": "^17.2.3",
+		"zod": "^4.1.13"
+	}
+}

package/src/cache/index.ts

@@ -0,0 +1,12 @@
+export type {
+	CacheAdapter,
+	CachedResolution,
+	GenerateCacheKeyFn,
+} from "./types.js"
+export { MemoryCache } from "./memory-cache.js"
+export { LocalFileStorage } from "./local-file-storage.js"
+export {
+	generateCacheKey,
+	generateToolSchemaHash,
+	normalizeServerIdentifier,
+} from "./utils.js"

package/src/cache/local-file-storage.ts

@@ -0,0 +1,72 @@
+import { existsSync, mkdirSync } from "node:fs"
+import { readdir, readFile, unlink, writeFile } from "node:fs/promises"
+import path from "node:path"
+import type { CacheAdapter, CachedResolution } from "./types.js"
+
+/**
+ * File-based cache adapter storing resolutions in a local directory.
+ * Each cached resolution is stored as a JSON file named by its key.
+ *
+ * Default directory: .smithery/ in the current working directory.
+ */
+export class LocalFileStorage implements CacheAdapter {
+	private readonly cacheDir: string
+
+	constructor(cacheDir?: string) {
+		this.cacheDir = cacheDir ?? path.join(process.cwd(), ".smithery")
+	}
+
+	private ensureDir(): void {
+		if (!existsSync(this.cacheDir)) {
+			mkdirSync(this.cacheDir, { recursive: true })
+		}
+	}
+
+	private getFilePath(key: string): string {
+		return path.join(this.cacheDir, `${key}.json`)
+	}
+
+	async get(key: string): Promise<CachedResolution | null> {
+		const filePath = this.getFilePath(key)
+
+		if (!existsSync(filePath)) {
+			return null
+		}
+
+		try {
+			const content = await readFile(filePath, "utf8")
+			return JSON.parse(content) as CachedResolution
+		} catch {
+			// File exists but is invalid - treat as cache miss
+			return null
+		}
+	}
+
+	async set(key: string, value: CachedResolution): Promise<void> {
+		this.ensureDir()
+		const filePath = this.getFilePath(key)
+		await writeFile(filePath, JSON.stringify(value, null, 2))
+	}
+
+	async delete(key: string): Promise<void> {
+		const filePath = this.getFilePath(key)
+
+		if (existsSync(filePath)) {
+			await unlink(filePath)
+		}
+	}
+
+	async clear(): Promise<void> {
+		if (!existsSync(this.cacheDir)) {
+			return
+		}
+
+		const files = await readdir(this.cacheDir, { withFileTypes: true })
+
+		await Promise.all(
+			files
+				.filter(file => file.isFile() && file.name.endsWith(".json"))
+				.map(file => unlink(path.join(this.cacheDir, file.name))),
+		)
+	}
+}

package/src/cache/memory-cache.ts

@@ -0,0 +1,33 @@
+import type { CacheAdapter, CachedResolution } from "./types.js"
+
+/**
+ * In-memory cache adapter using a Map.
+ * Useful for development, testing, or short-lived processes.
+ * Data is lost when the process terminates.
+ */
+export class MemoryCache implements CacheAdapter {
+	private cache: Map<string, CachedResolution> = new Map()
+
+	async get(key: string): Promise<CachedResolution | null> {
+		return this.cache.get(key) ?? null
+	}
+
+	async set(key: string, value: CachedResolution): Promise<void> {
+		this.cache.set(key, value)
+	}
+
+	async delete(key: string): Promise<void> {
+		this.cache.delete(key)
+	}
+
+	async clear(): Promise<void> {
+		this.cache.clear()
+	}
+
+	/**
+	 * Get the number of cached entries (for debugging)
+	 */
+	get size(): number {
+		return this.cache.size
+	}
+}

package/src/cache/types.ts

@@ -0,0 +1,55 @@
+/**
+ * A cached resolution of an intent to a tool call
+ */
+export interface CachedResolution {
+	/** Cache key (hash of intent + servers) */
+	key: string
+
+	/** Resolved server ID */
+	serverId: string
+
+	/** Resolved server qualified name */
+	serverQualifiedName: string
+
+	/** Resolved tool name */
+	toolName: string
+
+	/** Extracted parameters */
+	params: Record<string, unknown>
+
+	/** ISO timestamp of when this was resolved */
+	resolvedAt: string
+
+	/** Hash of the tool's input schema (for cache invalidation) */
+	toolSchemaHash: string
+}
+
+/**
+ * Interface for pluggable cache implementations
+ */
+export interface CacheAdapter {
+	/**
+	 * Get a cached resolution by key
+	 */
+	get(key: string): Promise<CachedResolution | null>
+
+	/**
+	 * Store a resolution in the cache
+	 */
+	set(key: string, value: CachedResolution): Promise<void>
+
+	/**
+	 * Delete a specific cache entry
+	 */
+	delete(key: string): Promise<void>
+
+	/**
+	 * Clear all cached entries
+	 */
+	clear(): Promise<void>
+}
+
+/**
+ * Function type for custom cache key generation
+ */
+export type GenerateCacheKeyFn = (prompt: string, servers: string[]) => string

package/src/cache/utils.ts

@@ -0,0 +1,44 @@
+import crypto from "node:crypto"
+
+/**
+ * Generates a deterministic cache key from a prompt and list of servers.
+ * Uses SHA-256 hash for a stable, filesystem-safe key.
+ */
+export function generateCacheKey(prompt: string, servers: string[]): string {
+	const normalizedPrompt = prompt.trim().toLowerCase()
+	const sortedServers = [...servers].sort()
+	const input = JSON.stringify({
+		prompt: normalizedPrompt,
+		servers: sortedServers,
+	})
+	return crypto.createHash("sha256").update(input).digest("hex")
+}
+
+/**
+ * Generates a hash of tool schemas for cache invalidation.
+ * If schemas change, the hash changes and cache is invalidated.
+ */
+export function generateToolSchemaHash(
+	tools: Array<{ name: string; inputSchema: unknown }>,
+): string {
+	const sortedTools = [...tools].sort((a, b) => a.name.localeCompare(b.name))
+	const schemaData = sortedTools.map(t => ({
+		name: t.name,
+		schema: t.inputSchema,
+	}))
+	return crypto
+		.createHash("sha256")
+		.update(JSON.stringify(schemaData))
+		.digest("hex")
+}
+
+/**
+ * Normalizes a server identifier for consistent cache key generation.
+ * Removes protocol and trailing slashes.
+ */
+export function normalizeServerIdentifier(server: string): string {
+	return server
+		.replace(/^https?:\/\//, "")
+		.replace(/\/+$/, "")
+		.toLowerCase()
+}

package/src/errors.ts

@@ -0,0 +1,10 @@
+export class MCPAuthenticationRequiredError extends Error {
+	constructor(
+		message: string,
+		public readonly authorizationUrl: string,
+	) {
+		super(`\n\n⚠️ ⚠️ ⚠️ ⚠️ ⚠️\n${message}\n\n${authorizationUrl}\n⚠️ ⚠️ ⚠️ ⚠️ ⚠️\n\n`)
+		this.name = "MCPAuthenticationRequiredError"
+		this.authorizationUrl = authorizationUrl
+	}
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./cache/index.js"
+export * from "./errors.js"
+export * from "./types.js"
+export { Runner } from "./runner.js"

package/src/runner.ts

@@ -0,0 +1,440 @@
+import {
+	addServerToProfile,
+	callTool,
+	exchangeApiKeyForToken,
+	listTools,
+} from "@smithery/runner"
+import type { Tool } from "@modelcontextprotocol/sdk/types.js"
+import { generateText, jsonSchema, Output, stepCountIs, tool } from "ai"
+import type { z } from "zod"
+
+import type {
+	CacheAdapter,
+	CachedResolution,
+	GenerateCacheKeyFn,
+} from "./cache/types.js"
+import {
+	generateCacheKey as defaultGenerateCacheKey,
+	generateToolSchemaHash,
+	normalizeServerIdentifier,
+} from "./cache/utils.js"
+import { MCPAuthenticationRequiredError } from "./errors.js"
+import {
+	type ActOptions,
+	type ConnectionConfig,
+	defaultSchema,
+	emptyInputSchema,
+	type OnAuthenticationRequiredCallback,
+	type PlanOptions,
+	type PollResult,
+	type RunnerInitOptions,
+	type RunOptions,
+	type ServerInput,
+	type ToolCallTemplate,
+} from "./types.js"
+import { fillTemplate, getSchemaKeys } from "./utils.js"
+
+export class Runner {
+	private readonly serviceToken: string
+	private readonly profileSlug: string
+	private serverConfigMap: Map<string, string> = new Map()
+	private onAuthenticationRequired?: OnAuthenticationRequiredCallback
+	private cache?: CacheAdapter
+	private generateCacheKey: GenerateCacheKeyFn
+
+	// Returns a set of server URLs that have been connected to the runner
+	public get servers(): Set<string> {
+		return new Set(this.serverConfigMap.keys())
+	}
+
+	/**
+	 * NOTE: This constructor is private to prevent direct instantiation.
+	 * Use the static init() method to create a new Runner instance.
+	 */
+	private constructor({
+		profileSlug,
+		serviceToken,
+		onAuthenticationRequired,
+		cache,
+		generateCacheKey,
+	}: {
+		profileSlug: string
+		serviceToken: string
+		onAuthenticationRequired?: OnAuthenticationRequiredCallback
+		cache?: CacheAdapter
+		generateCacheKey?: GenerateCacheKeyFn
+	}) {
+		this.profileSlug = profileSlug
+		this.serviceToken = serviceToken
+		this.onAuthenticationRequired = onAuthenticationRequired
+		this.cache = cache
+		this.generateCacheKey = generateCacheKey ?? defaultGenerateCacheKey
+	}
+
+	public static async init({
+		apiKey = process.env.SMITHERY_API_KEY,
+		onAuthenticationRequired,
+		cache,
+		generateCacheKey,
+	}: RunnerInitOptions = {}): Promise<Runner> {
+		if (!apiKey) {
+			throw new Error(
+				"API key is required. Get one from: https://smithery.ai/account/api-keys",
+			)
+		}
+
+		const { serviceToken, profileSlug } = await exchangeApiKeyForToken(apiKey)
+
+		return new Runner({
+			profileSlug,
+			serviceToken,
+			onAuthenticationRequired,
+			cache,
+			generateCacheKey,
+		})
+	}
+
+	private getServerUrl(server: string): string {
+		return server.startsWith("http://") || server.startsWith("https://")
+			? server
+			: `https://server.smithery.ai/${server}/mcp`
+	}
+
+	public async use(server: string): Promise<ConnectionConfig> {
+		// Delegate to resolveServerInput which handles auth callbacks and caching
+		return this.resolveServerInput(server)
+	}
+
+	/**
+	 * Polls the connection status for a server.
+	 * Returns status without throwing errors.
+	 *
+	 * @param server - Server name or URL
+	 * @returns "success" if connected, "needs_auth" if auth required, "error" if failed
+	 */
+	public async poll(server: string): Promise<PollResult> {
+		// Check if already connected
+		if (this.serverConfigMap.has(server)) {
+			return "success"
+		}
+
+		const serverUrl = this.getServerUrl(server)
+
+		// Attempt connection
+		const addResult = await addServerToProfile({
+			profileSlug: this.profileSlug,
+			input: { mcpUrl: serverUrl },
+			token: this.serviceToken,
+		})
+
+		if (addResult.status.state === "connected") {
+			// Cache the successful connection
+			this.serverConfigMap.set(server, addResult.configId)
+			return "success"
+		}
+
+		if (addResult.status.state === "auth_required") {
+			return "needs_auth"
+		}
+
+		return "error"
+	}
+
+	/**
+	 * Resolves a ServerInput to a ConnectionConfig, connecting on-the-fly if needed.
+	 */
+	private async resolveServerInput(
+		input: ServerInput,
+	): Promise<ConnectionConfig> {
+		// Already a ConnectionConfig - return as-is
+		if (typeof input !== "string") {
+			return input
+		}
+
+		// String server name - check if already connected
+		const server = input
+		const existingConfigId = this.serverConfigMap.get(server)
+		if (existingConfigId) {
+			return {
+				serverUrl: this.getServerUrl(server),
+				configId: existingConfigId,
+			}
+		}
+
+		// Connect on-the-fly (same logic as use())
+		const serverUrl = this.getServerUrl(server)
+		let addResult = await addServerToProfile({
+			profileSlug: this.profileSlug,
+			input: { mcpUrl: serverUrl },
+			token: this.serviceToken,
+		})
+
+		// Handle auth required
+		if (addResult.status.state === "auth_required") {
+			if (this.onAuthenticationRequired) {
+				// Call the callback (expected to block until auth completes)
+				await this.onAuthenticationRequired(
+					addResult.status.authorizationUrl,
+					serverUrl,
+				)
+				// Retry connection after callback returns
+				addResult = await addServerToProfile({
+					profileSlug: this.profileSlug,
+					input: { mcpUrl: serverUrl },
+					token: this.serviceToken,
+				})
+			} else {
+				// No callback - throw immediately
+				throw new MCPAuthenticationRequiredError(
+					`Authentication required. To authenticate, visit the following URL and follow the instructions:`,
+					addResult.status.authorizationUrl,
+				)
+			}
+		}
+
+		if (addResult.status.state !== "connected") {
+			throw new Error(
+				`Failed to connect to MCP server: ${JSON.stringify(addResult.status)}`,
+			)
+		}
+
+		// Cache the connection
+		this.serverConfigMap.set(server, addResult.configId)
+		return { serverUrl, configId: addResult.configId }
+	}
+
+	public async listTools(): Promise<Tool[]> {
+		const tools = await Promise.all(
+			Array.from(this.serverConfigMap.entries()).map(async ([_, configId]) => {
+				return await listTools(this.profileSlug, configId, this.serviceToken)
+			}),
+		)
+		return tools.flat()
+	}
+
+	/**
+	 * Plans a tool call without executing it. Returns a serializable template
+	 * where input values are parameterized with {{key}} placeholders.
+	 */
+	public async plan<TInput extends z.ZodTypeAny = typeof emptyInputSchema>(
+		prompt: string,
+		using: ServerInput[],
+		options: PlanOptions<TInput> = {},
+	): Promise<ToolCallTemplate> {
+		const { model = "anthropic/claude-haiku-4.5" } = options
+		const inputSchema = (options.inputSchema ?? emptyInputSchema) as TInput
+
+		// Resolve all server inputs to ConnectionConfigs (connects on-the-fly if needed)
+		const resolvedConfigs = await Promise.all(
+			using.map(input => this.resolveServerInput(input)),
+		)
+
+		// Generate normalized server identifiers for cache key
+		const serverIds = using.map(s =>
+			typeof s === "string"
+				? normalizeServerIdentifier(s)
+				: normalizeServerIdentifier(s.serverUrl),
+		)
+
+		// Generate cache key
+		const cacheKey = this.generateCacheKey(prompt, serverIds)
+
+		// Get input keys from schema
+		const inputKeys = getSchemaKeys(inputSchema)
+
+		// Get tools from resolved servers, tracking which server provides each tool
+		const mcpToolsWithConfigs = await Promise.all(
+			resolvedConfigs.map(async (config: ConnectionConfig) => {
+				const tools = await listTools(
+					this.profileSlug,
+					config.configId,
+					this.serviceToken,
+				)
+				return tools.map((t: Tool) => ({
+					tool: t,
+					configId: config.configId,
+					serverUrl: config.serverUrl,
+				}))
+			}),
+		).then(tools => tools.flat())
+
+		// Calculate tool schema hash for cache validation
+		const toolSchemaHash = generateToolSchemaHash(
+			mcpToolsWithConfigs.map(({ tool: mcpTool }: { tool: Tool }) => ({
+				name: mcpTool.name,
+				inputSchema: mcpTool.inputSchema,
+			})),
+		)
+
+		// Check cache before LLM call
+		if (this.cache) {
+			try {
+				const cached = await this.cache.get(cacheKey)
+				if (cached && cached.toolSchemaHash === toolSchemaHash) {
+					// Cache hit with valid schema - return cached template
+					return {
+						toolName: cached.toolName,
+						argsTemplate: cached.params,
+						server: cached.serverId,
+					}
+				}
+			} catch {
+				// Cache error - fall through to LLM call
+			}
+		}
+
+		// Build tool -> server lookup
+		const toolServerMap = new Map<string, string>()
+		for (const { tool: mcpTool, serverUrl } of mcpToolsWithConfigs) {
+			toolServerMap.set(mcpTool.name, serverUrl)
+		}
+
+		// Create tools WITHOUT execute functions (plan mode - no execution)
+		const aiTools = Object.fromEntries(
+			mcpToolsWithConfigs.map(({ tool: mcpTool }: { tool: Tool }) => [
+				mcpTool.name,
+				tool({
+					description: mcpTool.description ?? "",
+					inputSchema: jsonSchema(mcpTool.inputSchema),
+				}),
+			]),
+		)
+
+		// Build system prompt instructing AI to use placeholders
+		const systemPrompt =
+			inputKeys.length > 0
+				? `You have access to the following input variables that will be provided at runtime. Use them as {{variableName}} placeholders in your tool arguments:
+${inputKeys.map((key: string) => `- {{${key}}}`).join("\n")}
+
+IMPORTANT: When a tool argument should use one of these variables, use the {{variableName}} syntax exactly. Do not use literal values for these variables.`
+				: undefined
+
+		// Call generateText with stopWhen to get exactly one tool call
+		const result = await generateText({
+			model,
+			tools: aiTools,
+			prompt,
+			toolChoice: "required",
+			stopWhen: stepCountIs(1),
+			...(systemPrompt ? { system: systemPrompt } : {}),
+		})
+
+		// Extract the tool call
+		const toolCall = result.toolCalls[0]
+		if (!toolCall) {
+			throw new Error("No tool call was generated by the model")
+		}
+
+		const serverUrl = toolServerMap.get(toolCall.toolName)
+		if (!serverUrl) {
+			throw new Error(`No server found for tool: ${toolCall.toolName}`)
+		}
+
+		// Store result in cache
+		if (this.cache) {
+			try {
+				const resolution: CachedResolution = {
+					key: cacheKey,
+					serverId: serverUrl,
+					serverQualifiedName: serverUrl,
+					toolName: toolCall.toolName,
+					params: toolCall.input as Record<string, unknown>,
+					resolvedAt: new Date().toISOString(),
+					toolSchemaHash,
+				}
+				await this.cache.set(cacheKey, resolution)
+			} catch {
+				// Cache error - continue without caching
+			}
+		}
+
+		// Return serializable template with server info
+		return {
+			toolName: toolCall.toolName,
+			argsTemplate: toolCall.input as Record<string, unknown>,
+			server: serverUrl,
+		}
+	}
+
+	/**
+	 * Executes a tool call template with the provided input values.
+	 * Completely decoupled from plan() - can be called from a different endpoint.
+	 * Uses the server URL from the template to resolve the connection.
+	 */
+	public async run<TOutput extends z.ZodTypeAny = typeof defaultSchema>(
+		template: ToolCallTemplate,
+		input: Record<string, unknown>,
+		options: RunOptions<TOutput> = {},
+	): Promise<z.infer<TOutput>> {
+		const { model = "anthropic/claude-haiku-4.5" } = options
+		const outputSchema = (options.outputSchema ?? defaultSchema) as TOutput
+		const hasCustomOutputSchema = options.outputSchema !== undefined
+
+		// Resolve server - could be serverUrl or server name, connects on-the-fly if needed
+		let configId = this.serverConfigMap.get(template.server)
+		if (!configId) {
+			// Try to connect on-the-fly
+			const resolved = await this.resolveServerInput(template.server)
+			configId = resolved.configId
+		}
+
+		// Fill template placeholders with input values
+		const filledArgs = fillTemplate(template.argsTemplate, input)
+
+		console.log(`Calling MCP tool: ${template.toolName} with args:`, filledArgs)
+
+		// Execute the tool
+		const result = await callTool(
+			this.profileSlug,
+			configId,
+			template.toolName,
+			filledArgs,
+			this.serviceToken,
+		)
+
+		console.log("result", result)
+
+		if (result.isError) {
+			throw new Error(`Tool execution error: ${JSON.stringify(result.content)}`)
+		}
+
+		// If outputSchema is provided, use generateText to conform result
+		if (hasCustomOutputSchema) {
+			const { output } = await generateText({
+				model,
+				prompt: `Based on the following tool result, extract and structure the information according to the schema.\n\nTool: ${template.toolName}\nResult: ${JSON.stringify(result.content)}`,
+				output: Output.object({ schema: outputSchema }),
+			})
+			return output as z.infer<TOutput>
+		}
+
+		// Return raw result wrapped in default schema format
+		return { result: JSON.stringify(result.content) } as z.infer<TOutput>
+	}
+
+	/**
+	 * Acts on a prompt by determining which tool to call and executing it.
+	 * Convenience method that combines plan() + run().
+	 */
+	public async act<
+		TInput extends z.ZodTypeAny = typeof emptyInputSchema,
+		TOutput extends z.ZodTypeAny = typeof defaultSchema,
+	>(
+		prompt: string,
+		using: ServerInput[],
+		options: ActOptions<TInput, TOutput> = {},
+	): Promise<z.infer<TOutput>> {
+		const template = await this.plan(prompt, using, {
+			model: options.model,
+			inputSchema: options.inputSchema,
+		})
+		return this.run(
+			template,
+			{},
+			{
+				model: options.model,
+				outputSchema: options.outputSchema,
+			},
+		)
+	}
+}

package/src/types.ts

@@ -0,0 +1,59 @@
+import type { LanguageModel } from "ai"
+import { z } from "zod"
+import type { CacheAdapter, GenerateCacheKeyFn } from "./cache/types.js"
+
+export type ConnectionConfig = {
+	serverUrl: string
+	configId: string
+}
+
+// Union type for act/plan's `using` parameter - accepts either pre-connected config or server name string
+export type ServerInput = ConnectionConfig | string
+
+// Poll result type
+export type PollResult = "success" | "needs_auth" | "error"
+
+// Auth callback type - called when authentication is required during connection
+export type OnAuthenticationRequiredCallback = (
+	authorizationUrl: string,
+	serverUrl: string,
+) => Promise<void>
+
+// Init options type
+export type RunnerInitOptions = {
+	apiKey?: string
+	onAuthenticationRequired?: OnAuthenticationRequiredCallback
+	/** Optional cache adapter for storing plan() resolutions */
+	cache?: CacheAdapter
+	/** Optional custom cache key generation function */
+	generateCacheKey?: GenerateCacheKeyFn
+}
+
+export const defaultSchema = z.object({ result: z.string() })
+export const emptyInputSchema = z.object({})
+
+// Serializable template returned by plan()
+export type ToolCallTemplate = {
+	toolName: string
+	argsTemplate: Record<string, unknown>
+	server: string // server URL to execute the tool on
+}
+
+// Options for plan()
+export type PlanOptions<TInput extends z.ZodTypeAny = typeof emptyInputSchema> =
+	{
+		model?: LanguageModel
+		inputSchema?: TInput
+	}
+
+// Options for run()
+export type RunOptions<TOutput extends z.ZodTypeAny = typeof defaultSchema> = {
+	model?: LanguageModel
+	outputSchema?: TOutput
+}
+
+// Options for act() - combines plan + run options
+export type ActOptions<
+	TInput extends z.ZodTypeAny = typeof emptyInputSchema,
+	TOutput extends z.ZodTypeAny = typeof defaultSchema,
+> = PlanOptions<TInput> & RunOptions<TOutput>

package/src/utils.ts

@@ -0,0 +1,43 @@
+import { z } from "zod"
+
+/**
+ * Fills {{key}} placeholders in template with input values.
+ */
+export function fillTemplate(
+	template: Record<string, unknown>,
+	input: Record<string, unknown>,
+): Record<string, unknown> {
+	function fillValue(value: unknown): unknown {
+		if (typeof value === "string") {
+			return value.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+				if (key in input) {
+					return String(input[key])
+				}
+				return match
+			})
+		}
+		if (Array.isArray(value)) {
+			return value.map(fillValue)
+		}
+		if (value !== null && typeof value === "object") {
+			return fillTemplate(value as Record<string, unknown>, input)
+		}
+		return value
+	}
+
+	const result: Record<string, unknown> = {}
+	for (const [key, value] of Object.entries(template)) {
+		result[key] = fillValue(value)
+	}
+	return result
+}
+
+/**
+ * Extracts the keys from a Zod object schema.
+ */
+export function getSchemaKeys(schema: z.ZodTypeAny): string[] {
+	if (schema instanceof z.ZodObject) {
+		return Object.keys(schema.shape)
+	}
+	return []
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "@smithery/typescript-config/tsconfig.json",
+	"compilerOptions": {
+		"outDir": "dist",
+		"rootDir": "src"
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}