@pikku/core 0.11.2 → 0.12.0

package/dist/version.d.ts

@@ -0,0 +1,6 @@
+export declare function formatVersionedId(baseName: string, version: number): string;
+export declare function parseVersionedId(id: string): {
+    baseName: string;
+    version: number | null;
+};
+export declare function isVersionedId(id: string): boolean;

package/dist/version.js

@@ -0,0 +1,19 @@
+const VERSION_SEPARATOR = '@v';
+export function formatVersionedId(baseName, version) {
+    return `${baseName}${VERSION_SEPARATOR}${version}`;
+}
+export function parseVersionedId(id) {
+    const idx = id.lastIndexOf(VERSION_SEPARATOR);
+    if (idx === -1) {
+        return { baseName: id, version: null };
+    }
+    const versionStr = id.slice(idx + VERSION_SEPARATOR.length);
+    const version = Number(versionStr);
+    if (!Number.isInteger(version) || version < 1) {
+        return { baseName: id, version: null };
+    }
+    return { baseName: id.slice(0, idx), version };
+}
+export function isVersionedId(id) {
+    return parseVersionedId(id).version !== null;
+}

package/dist/wirings/ai-agent/ai-agent-memory.d.ts

@@ -0,0 +1,29 @@
+import type { CoreSingletonServices } from '../../types/core.types.js';
+import type { CoreAIAgent, AIAgentMemoryConfig, AIAgentInput, AIMessage } from './ai-agent.types.js';
+import type { AIStorageService } from '../../services/ai-storage-service.js';
+import type { Logger } from '../../services/logger.js';
+import type { SchemaService } from '../../services/schema-service.js';
+export declare function resolveMemoryServices(agent: CoreAIAgent, singletonServices: CoreSingletonServices): {
+    storage: AIStorageService | undefined;
+};
+export declare function deepMergeWorkingMemory(existing: Record<string, unknown>, updates: Record<string, unknown>): Record<string, unknown>;
+export declare function buildWorkingMemoryPrompt(currentState: Record<string, unknown> | null, jsonSchema?: Record<string, unknown>): string;
+export declare function loadContextMessages(memoryConfig: AIAgentMemoryConfig | undefined, storage: AIStorageService | undefined, input: AIAgentInput, workingMemoryJsonSchema?: Record<string, unknown>): Promise<AIMessage[]>;
+export declare function saveMessages(storage: AIStorageService | undefined, threadId: string, resourceId: string, memoryConfig: AIAgentMemoryConfig | undefined, userMessage: AIMessage, result: {
+    text: string;
+    steps: {
+        toolCalls?: {
+            name: string;
+            args: Record<string, unknown>;
+            result: string;
+        }[];
+    }[];
+}, options?: {
+    workingMemoryJsonSchema?: Record<string, unknown>;
+    workingMemorySchemaName?: string | null;
+    logger?: Logger;
+    schemaService?: SchemaService;
+}): Promise<string>;
+export declare function trimMessages(messages: AIMessage[], maxTokenBudget?: number): AIMessage[];
+export declare function parseWorkingMemory(text: string): Record<string, unknown> | null;
+export declare function stripWorkingMemoryTags(text: string): string;

package/dist/wirings/ai-agent/ai-agent-memory.js

@@ -0,0 +1,199 @@
+import { randomUUID } from 'crypto';
+export function resolveMemoryServices(agent, singletonServices) {
+    const memoryConfig = agent.memory;
+    const storage = memoryConfig?.storage
+        ? singletonServices[memoryConfig.storage]
+        : singletonServices.aiStorage;
+    return { storage };
+}
+export function deepMergeWorkingMemory(existing, updates) {
+    const result = { ...existing };
+    for (const key of Object.keys(updates)) {
+        const value = updates[key];
+        if (value === null) {
+            delete result[key];
+        }
+        else if (typeof value === 'object' &&
+            !Array.isArray(value) &&
+            typeof result[key] === 'object' &&
+            result[key] !== null &&
+            !Array.isArray(result[key])) {
+            result[key] = deepMergeWorkingMemory(result[key], value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export function buildWorkingMemoryPrompt(currentState, jsonSchema) {
+    const parts = [];
+    if (jsonSchema?.properties) {
+        const props = jsonSchema.properties;
+        const fieldLines = Object.entries(props).map(([name, def]) => {
+            const type = def.type ?? 'unknown';
+            const desc = def.description ? ` - ${def.description}` : '';
+            return `  - ${name} (${type})${desc}`;
+        });
+        if (fieldLines.length > 0) {
+            parts.push(`Working memory fields:\n${fieldLines.join('\n')}`);
+        }
+    }
+    if (currentState && Object.keys(currentState).length > 0) {
+        parts.push(`Current working memory:\n${JSON.stringify(currentState)}`);
+    }
+    else {
+        parts.push('Current working memory: (empty)');
+    }
+    parts.push('When you learn new information, output a partial JSON update in <working_memory> tags. ' +
+        'Only include changed fields. Set a field to null to delete it.');
+    return parts.join('\n\n');
+}
+export async function loadContextMessages(memoryConfig, storage, input, workingMemoryJsonSchema) {
+    const contextMessages = [];
+    if (memoryConfig?.workingMemory && storage) {
+        const workingMem = await storage.getWorkingMemory(input.threadId, 'thread');
+        const prompt = buildWorkingMemoryPrompt(workingMem, workingMemoryJsonSchema);
+        contextMessages.push({
+            id: `wm-${randomUUID()}`,
+            role: 'system',
+            content: prompt,
+            createdAt: new Date(),
+        });
+    }
+    return contextMessages;
+}
+export async function saveMessages(storage, threadId, resourceId, memoryConfig, userMessage, result, options) {
+    let responseText = result.text;
+    if (storage) {
+        const newMessages = [userMessage];
+        for (const step of result.steps) {
+            if (step.toolCalls?.length) {
+                newMessages.push({
+                    id: randomUUID(),
+                    role: 'assistant',
+                    toolCalls: step.toolCalls.map((tc) => ({
+                        id: randomUUID(),
+                        name: tc.name,
+                        args: tc.args,
+                    })),
+                    createdAt: new Date(),
+                });
+                newMessages.push({
+                    id: randomUUID(),
+                    role: 'tool',
+                    toolResults: step.toolCalls.map((tc) => ({
+                        id: randomUUID(),
+                        name: tc.name,
+                        result: tc.result,
+                    })),
+                    createdAt: new Date(),
+                });
+            }
+        }
+        newMessages.push({
+            id: randomUUID(),
+            role: 'assistant',
+            content: responseText,
+            createdAt: new Date(),
+        });
+        await storage.saveMessages(threadId, newMessages);
+        if (memoryConfig?.workingMemory) {
+            const parsed = parseWorkingMemory(responseText);
+            if (parsed) {
+                const existing = (await storage.getWorkingMemory(threadId, 'thread')) ?? {};
+                const merged = deepMergeWorkingMemory(existing, parsed);
+                if (options?.schemaService && options?.workingMemorySchemaName) {
+                    try {
+                        await options.schemaService.validateSchema(options.workingMemorySchemaName, merged);
+                    }
+                    catch (err) {
+                        options.logger?.warn(`Working memory validation failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+                await storage.saveWorkingMemory(threadId, 'thread', merged);
+                responseText = stripWorkingMemoryTags(responseText);
+            }
+        }
+    }
+    return responseText;
+}
+export function trimMessages(messages, maxTokenBudget = 100000) {
+    const sanitized = sanitizeToolMessages(messages);
+    let estimatedTokens = 0;
+    const result = [];
+    for (let i = sanitized.length - 1; i >= 0; i--) {
+        const msg = sanitized[i];
+        const msgTokens = estimateTokens(msg);
+        if (estimatedTokens + msgTokens > maxTokenBudget && result.length > 0) {
+            break;
+        }
+        estimatedTokens += msgTokens;
+        result.unshift(msg);
+    }
+    if (result.length > 0 &&
+        result[0].role !== 'user' &&
+        result[0].role !== 'system') {
+        const firstUserIdx = result.findIndex((m) => m.role === 'user' || m.role === 'system');
+        if (firstUserIdx > 0) {
+            return result.slice(firstUserIdx);
+        }
+    }
+    return result;
+}
+function sanitizeToolMessages(messages) {
+    const result = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === 'assistant' && msg.toolCalls?.length) {
+            const next = messages[i + 1];
+            if (!next || next.role !== 'tool' || !next.toolResults?.length) {
+                if (msg.content) {
+                    result.push({ ...msg, toolCalls: undefined });
+                }
+                continue;
+            }
+            const toolCallIds = new Set(msg.toolCalls.map((tc) => tc.id));
+            const resultIds = new Set(next.toolResults.map((tr) => tr.id));
+            const allMatched = [...toolCallIds].every((id) => resultIds.has(id));
+            if (!allMatched) {
+                if (msg.content) {
+                    result.push({ ...msg, toolCalls: undefined });
+                }
+                result.push({
+                    ...next,
+                    toolResults: next.toolResults.filter((tr) => !toolCallIds.has(tr.id)) ||
+                        undefined,
+                });
+                i++;
+                continue;
+            }
+        }
+        result.push(msg);
+    }
+    return result.filter((m) => m.role !== 'tool' || (m.toolResults && m.toolResults.length > 0));
+}
+function estimateTokens(msg) {
+    let chars = 0;
+    if (msg.content)
+        chars += msg.content.length;
+    if (msg.toolCalls)
+        chars += JSON.stringify(msg.toolCalls).length;
+    if (msg.toolResults)
+        chars += JSON.stringify(msg.toolResults).length;
+    return Math.ceil(chars / 4);
+}
+export function parseWorkingMemory(text) {
+    const match = text.match(/<working_memory>([\s\S]*?)<\/working_memory>/);
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(match[1].trim());
+    }
+    catch {
+        return null;
+    }
+}
+export function stripWorkingMemoryTags(text) {
+    return text.replace(/<working_memory>[\s\S]*?<\/working_memory>/g, '').trim();
+}

package/dist/wirings/ai-agent/ai-agent-model-config.d.ts

@@ -0,0 +1,9 @@
+export declare function resolveModelConfig(agentName: string, agent: {
+    model: string;
+    temperature?: number;
+    maxSteps?: number;
+}): {
+    model: string;
+    temperature?: number;
+    maxSteps?: number;
+};

package/dist/wirings/ai-agent/ai-agent-model-config.js

@@ -0,0 +1,36 @@
+import { pikkuState } from '../../pikku-state.js';
+export function resolveModelConfig(agentName, agent) {
+    let config = {};
+    try {
+        config = pikkuState(null, 'models', 'config') ?? {};
+    }
+    catch { }
+    const models = config.models ?? {};
+    const defaults = config.agentDefaults;
+    const agentOverride = config.agentOverrides?.[agentName];
+    let rawModel = agentOverride?.model ?? agent.model;
+    let aliasTemperature;
+    let aliasMaxSteps;
+    if (!rawModel.includes('/')) {
+        const entry = models[rawModel];
+        if (!entry)
+            throw new Error(`Unknown model alias '${rawModel}'.`);
+        if (typeof entry === 'string') {
+            rawModel = entry;
+        }
+        else {
+            rawModel = entry.model;
+            aliasTemperature = entry.temperature;
+            aliasMaxSteps = entry.maxSteps;
+        }
+    }
+    const temperature = agentOverride?.temperature ??
+        aliasTemperature ??
+        defaults?.temperature ??
+        agent.temperature;
+    const maxSteps = agentOverride?.maxSteps ??
+        aliasMaxSteps ??
+        defaults?.maxSteps ??
+        agent.maxSteps;
+    return { model: rawModel, temperature, maxSteps };
+}

package/dist/wirings/ai-agent/ai-agent-prepare.d.ts

@@ -0,0 +1,60 @@
+import { type CoreSingletonServices, type CoreServices, type CoreUserSession, type CreateWireServices } from '../../types/core.types.js';
+import type { CoreAIAgent, AIAgentInput, AIAgentToolDef, AIMessage, AIStreamChannel } from './ai-agent.types.js';
+import type { AIAgentRunnerParams } from '../../services/ai-agent-runner-service.js';
+import { PikkuError } from '../../errors/error-handler.js';
+import type { SessionService } from '../../services/user-session-service.js';
+export type RunAIAgentParams = {
+    singletonServices: CoreSingletonServices;
+    sessionService?: SessionService<CoreUserSession>;
+    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+};
+export type StreamAIAgentOptions = {
+    requiresToolApproval?: 'all' | 'explicit' | false;
+};
+export declare class ToolApprovalRequired extends PikkuError {
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly args: unknown;
+    readonly reason?: string;
+    readonly displayToolName?: string;
+    readonly displayArgs?: unknown;
+    readonly agentRunId?: string;
+    constructor(toolCallId: string, toolName: string, args: unknown, reason?: string, displayToolName?: string, displayArgs?: unknown, agentRunId?: string);
+}
+export type StreamContext = {
+    channel: AIStreamChannel;
+    options?: StreamAIAgentOptions;
+};
+export declare const resolveAgent: (agentName: string) => {
+    agent: CoreAIAgent;
+    packageName: string | null;
+    resolvedName: string;
+};
+export declare function buildInstructions(agentName: string, packageName: string | null): string;
+export type ScopedChannel = AIStreamChannel & {
+    approval: {
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+        runId: string;
+    } | null;
+};
+export declare function createScopedChannel(parent: AIStreamChannel, agentName: string, session: string): ScopedChannel;
+export declare function buildToolDefs(singletonServices: CoreSingletonServices, params: RunAIAgentParams, agentSessionMap: Map<string, string>, resourceId: string, agentName: string, packageName: string | null, streamContext?: StreamContext): {
+    tools: AIAgentToolDef[];
+    missingRpcs: string[];
+};
+export declare function prepareAgentRun(agentName: string, input: AIAgentInput, params: RunAIAgentParams, agentSessionMap: Map<string, string>, streamContext?: StreamContext): Promise<{
+    agent: CoreAIAgent;
+    packageName: string | null;
+    resolvedName: string;
+    agentRunner: import("../../services/ai-agent-runner-service.js").AIAgentRunnerService;
+    storage: import("../../services/ai-storage-service.js").AIStorageService | undefined;
+    memoryConfig: import("./ai-agent.types.js").AIAgentMemoryConfig | undefined;
+    threadId: string;
+    userMessage: AIMessage;
+    runnerParams: AIAgentRunnerParams;
+    missingRpcs: string[];
+    workingMemoryJsonSchema: any;
+    workingMemorySchemaName: string | null;
+}>;

package/dist/wirings/ai-agent/ai-agent-prepare.js

@@ -0,0 +1,312 @@
+import { PikkuError } from '../../errors/error-handler.js';
+import { pikkuState } from '../../pikku-state.js';
+import { runPikkuFunc } from '../../function/function-runner.js';
+import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js';
+import { randomUUID } from 'crypto';
+import { resolveMemoryServices, loadContextMessages, trimMessages, } from './ai-agent-memory.js';
+import { resolveModelConfig } from './ai-agent-model-config.js';
+export class ToolApprovalRequired extends PikkuError {
+    toolCallId;
+    toolName;
+    args;
+    reason;
+    displayToolName;
+    displayArgs;
+    agentRunId;
+    constructor(toolCallId, toolName, args, reason, displayToolName, displayArgs, agentRunId) {
+        super(`Tool '${displayToolName ?? toolName}' requires approval`);
+        this.toolCallId = toolCallId;
+        this.toolName = toolName;
+        this.args = args;
+        this.reason = reason;
+        this.displayToolName = displayToolName;
+        this.displayArgs = displayArgs;
+        this.agentRunId = agentRunId;
+    }
+}
+export const resolveAgent = (agentName) => {
+    const mainAgent = pikkuState(null, 'agent', 'agents').get(agentName);
+    if (mainAgent) {
+        return { agent: mainAgent, packageName: null, resolvedName: agentName };
+    }
+    const colonIndex = agentName.indexOf(':');
+    if (colonIndex !== -1) {
+        const namespace = agentName.substring(0, colonIndex);
+        const localName = agentName.substring(colonIndex + 1);
+        const externalPackages = pikkuState(null, 'rpc', 'externalPackages');
+        const pkgConfig = externalPackages.get(namespace);
+        if (pkgConfig) {
+            const extAgent = pikkuState(pkgConfig.package, 'agent', 'agents').get(localName);
+            if (extAgent) {
+                return {
+                    agent: extAgent,
+                    packageName: pkgConfig.package,
+                    resolvedName: localName,
+                };
+            }
+        }
+    }
+    throw new Error(`AI agent not found: ${agentName}`);
+};
+export function buildInstructions(agentName, packageName) {
+    const meta = pikkuState(packageName, 'agent', 'agentsMeta')[agentName];
+    const instructions = meta?.instructions ?? '';
+    const baseInstructions = Array.isArray(instructions)
+        ? instructions.join('\n')
+        : instructions;
+    return meta?.agents?.length
+        ? baseInstructions +
+            '\n\nWhen calling a sub-agent, provide a short session name that describes the task. ' +
+            'Use the same session name to continue a previous conversation with that agent. ' +
+            'Use a new session name for a new independent task.'
+        : baseInstructions;
+}
+export function createScopedChannel(parent, agentName, session) {
+    let capturedApproval = null;
+    return {
+        channelId: `${parent.channelId}:${agentName}:${session}`,
+        openingData: parent.openingData,
+        get state() {
+            return parent.state;
+        },
+        get approval() {
+            return capturedApproval;
+        },
+        close: () => { },
+        send: (event) => {
+            if (event.type === 'done')
+                return;
+            if (event.type === 'approval-request') {
+                capturedApproval = {
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    args: event.args,
+                    runId: event.runId,
+                };
+                return;
+            }
+            if (event.type === 'text-delta' ||
+                event.type === 'reasoning-delta' ||
+                event.type === 'tool-call' ||
+                event.type === 'tool-result' ||
+                event.type === 'usage' ||
+                event.type === 'error') {
+                parent.send({ ...event, agent: agentName, session });
+            }
+            else {
+                parent.send(event);
+            }
+        },
+    };
+}
+export function buildToolDefs(singletonServices, params, agentSessionMap, resourceId, agentName, packageName, streamContext) {
+    const tools = [];
+    const missingRpcs = [];
+    const approvalPolicy = streamContext?.options?.requiresToolApproval ?? 'explicit';
+    const meta = pikkuState(packageName, 'agent', 'agentsMeta')[agentName];
+    if (!meta)
+        return { tools, missingRpcs };
+    const metaTools = meta.tools;
+    const metaAgents = meta.agents;
+    if (metaTools?.length) {
+        const functionMeta = pikkuState(null, 'function', 'meta');
+        const schemas = pikkuState(null, 'misc', 'schemas');
+        for (const toolName of metaTools) {
+            const rpcMeta = pikkuState(null, 'rpc', 'meta');
+            const pikkuFuncId = rpcMeta[toolName];
+            if (!pikkuFuncId) {
+                missingRpcs.push(toolName);
+                continue;
+            }
+            const fnMeta = functionMeta[pikkuFuncId];
+            const inputSchemaName = fnMeta?.inputSchemaName;
+            let inputSchema = inputSchemaName
+                ? schemas.get(inputSchemaName)
+                : undefined;
+            if (!inputSchema ||
+                (typeof inputSchema === 'object' &&
+                    inputSchema.type === 'object' &&
+                    !inputSchema.properties)) {
+                inputSchema = { type: 'object', properties: {} };
+            }
+            const needsApproval = approvalPolicy === 'all' ||
+                (approvalPolicy === 'explicit' && fnMeta?.requiresApproval);
+            if (needsApproval) {
+                inputSchema = {
+                    ...inputSchema,
+                    properties: {
+                        ...(inputSchema.properties || {}),
+                        toolApprovalReason: {
+                            type: 'string',
+                            description: 'Brief explanation of why this action is needed',
+                        },
+                    },
+                };
+            }
+            tools.push({
+                name: pikkuFuncId,
+                description: fnMeta?.description || fnMeta?.title || toolName,
+                inputSchema,
+                execute: async (toolInput) => {
+                    if (needsApproval) {
+                        const { toolApprovalReason, ...cleanArgs } = toolInput;
+                        return {
+                            __approvalRequired: true,
+                            toolName: pikkuFuncId,
+                            args: cleanArgs,
+                            reason: toolApprovalReason,
+                        };
+                    }
+                    const wire = params.sessionService
+                        ? { ...createMiddlewareSessionWireProps(params.sessionService) }
+                        : {};
+                    return runPikkuFunc('agent', `tool:${pikkuFuncId}`, pikkuFuncId, {
+                        singletonServices,
+                        createWireServices: params.createWireServices,
+                        data: () => toolInput,
+                        wire,
+                        sessionService: params.sessionService,
+                    });
+                },
+            });
+        }
+    }
+    if (metaAgents?.length) {
+        const allAgentsMeta = pikkuState(null, 'agent', 'agentsMeta');
+        for (const subAgentName of metaAgents) {
+            const subMeta = allAgentsMeta[subAgentName];
+            if (!subMeta) {
+                singletonServices.logger.warn(`Sub-agent '${subAgentName}' not found in agent registry`);
+                continue;
+            }
+            tools.push({
+                name: subAgentName,
+                description: subMeta.description,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        message: { type: 'string' },
+                        session: {
+                            type: 'string',
+                            description: 'Short session label for thread continuity',
+                        },
+                    },
+                    required: ['message', 'session'],
+                },
+                execute: async (toolInput) => {
+                    const { message, session } = toolInput;
+                    const sessionKey = `${subAgentName}::${session}`;
+                    let threadId = agentSessionMap.get(sessionKey);
+                    if (!threadId) {
+                        threadId = `${subAgentName}-${session}-${Date.now()}`;
+                        agentSessionMap.set(sessionKey, threadId);
+                    }
+                    if (streamContext) {
+                        const { streamAIAgent } = await import('./ai-agent-stream.js');
+                        const { channel } = streamContext;
+                        channel.send({
+                            type: 'agent-call',
+                            agentName: subAgentName,
+                            session,
+                            input: message,
+                        });
+                        const subChannel = createScopedChannel(channel, subAgentName, session);
+                        await streamAIAgent(subAgentName, { message, threadId, resourceId }, subChannel, params, agentSessionMap, streamContext.options);
+                        if (subChannel.approval) {
+                            return {
+                                __approvalRequired: true,
+                                toolName: subAgentName,
+                                args: toolInput,
+                                displayToolName: subChannel.approval.toolName,
+                                displayArgs: subChannel.approval.args,
+                                agentRunId: subChannel.approval.runId,
+                            };
+                        }
+                        channel.send({
+                            type: 'agent-result',
+                            agentName: subAgentName,
+                            session,
+                            result: null,
+                        });
+                        return null;
+                    }
+                    const { runAIAgent } = await import('./ai-agent-runner.js');
+                    const result = await runAIAgent(subAgentName, { message, threadId, resourceId }, params, agentSessionMap);
+                    return result.object ?? result.text;
+                },
+            });
+        }
+    }
+    return { tools, missingRpcs };
+}
+export async function prepareAgentRun(agentName, input, params, agentSessionMap, streamContext) {
+    const { singletonServices } = params;
+    const { agent, packageName, resolvedName } = resolveAgent(agentName);
+    const agentRunner = singletonServices.aiAgentRunner;
+    if (!agentRunner) {
+        throw new Error('AIAgentRunnerService not available in singletonServices');
+    }
+    const { storage } = resolveMemoryServices(agent, singletonServices);
+    const memoryConfig = agent.memory;
+    const threadId = input.threadId;
+    const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
+    const meta = agentsMeta[resolvedName];
+    const outputSchemaName = meta?.outputSchema;
+    const outputSchema = outputSchemaName
+        ? pikkuState(packageName, 'misc', 'schemas').get(outputSchemaName)
+        : undefined;
+    const workingMemorySchemaName = meta?.workingMemorySchema ?? null;
+    const workingMemoryJsonSchema = workingMemorySchemaName
+        ? pikkuState(packageName, 'misc', 'schemas').get(workingMemorySchemaName)
+        : undefined;
+    if (storage) {
+        try {
+            await storage.getThread(threadId);
+        }
+        catch {
+            await storage.createThread(input.resourceId, { threadId });
+        }
+    }
+    let messages = [];
+    if (storage) {
+        messages = await storage.getMessages(threadId, {
+            lastN: memoryConfig?.lastMessages ?? 20,
+        });
+    }
+    const contextMessages = await loadContextMessages(memoryConfig, storage, input, workingMemoryJsonSchema);
+    const userMessage = {
+        id: randomUUID(),
+        role: 'user',
+        content: input.message,
+        createdAt: new Date(),
+    };
+    const allMessages = [...contextMessages, ...messages, userMessage];
+    const trimmedMessages = trimMessages(allMessages);
+    const { tools, missingRpcs } = buildToolDefs(singletonServices, params, agentSessionMap, input.resourceId, resolvedName, packageName, streamContext);
+    const instructions = buildInstructions(resolvedName, packageName);
+    const resolved = resolveModelConfig(resolvedName, agent);
+    const runnerParams = {
+        model: resolved.model,
+        temperature: resolved.temperature,
+        instructions,
+        messages: trimmedMessages,
+        tools,
+        maxSteps: resolved.maxSteps ?? 10,
+        toolChoice: agent.toolChoice ?? 'auto',
+        outputSchema,
+    };
+    return {
+        agent,
+        packageName,
+        resolvedName,
+        agentRunner,
+        storage,
+        memoryConfig,
+        threadId,
+        userMessage,
+        runnerParams,
+        missingRpcs,
+        workingMemoryJsonSchema,
+        workingMemorySchemaName,
+    };
+}