@pikku/core 0.11.2 → 0.12.1

package/dist/utils.d.ts

@@ -1,13 +1,14 @@
-import { Logger } from './services/logger.js';
-import { CoreSingletonServices } from './types/core.types.js';
-export declare const closeWireServices: (logger: Logger, wireServices: Record<string, any>) => Promise<void>;
+import type { Logger } from './services/logger.js';
+import type { WireServices } from './types/core.types.js';
+export declare const closeWireServices: (logger: Logger, wireServices: WireServices) => Promise<void>;
 export declare const createWeakUID: () => string;
 export declare const isSerializable: (data: any) => boolean;
+export declare const getTagGroups: <T>(tagGroups: Record<string, T>, tag: string) => T[];
 export declare const freezeDedupe: <T>(arr?: readonly T[] | T[] | undefined) => readonly T[];
 /**
- * Stop all singleton services, including external package services.
- * External package services are stopped first, then the parent services.
+ * Stop all singleton services, including addon package services.
+ * Addon package services are stopped first, then the parent services.
  *
  * @param singletonServices - The parent singleton services to stop
  */
-export declare const stopSingletonServices: (singletonServices: CoreSingletonServices) => Promise<void>;
+export declare const stopSingletonServices: () => Promise<void>;

package/dist/utils.js

@@ -1,6 +1,4 @@
-// TODO: WireServices probably needs it's own type
-// but is an issue for the future and will be tackled
-// with dependency injection
+import { getSingletonServices, getAllPackageStates } from './pikku-state.js';
 export const closeWireServices = async (logger, wireServices) => {
     await Promise.all(Object.values(wireServices).map(async (service) => {
         if (service?.close) {
@@ -13,9 +11,9 @@ export const closeWireServices = async (logger, wireServices) => {
         }
     }));
 };
-export const createWeakUID = () => {
-    return Date.now().toString(36) + Math.random().toString(36).substring(2, 10);
-};
+const _uidPrefix = Date.now().toString(36);
+let _uidCounter = 0;
+export const createWeakUID = () => `${_uidPrefix}-${++_uidCounter}`;
 export const isSerializable = (data) => {
     return !(typeof data === 'string' ||
         data instanceof ArrayBuffer ||
@@ -28,6 +26,21 @@ export const isSerializable = (data) => {
         data instanceof Float32Array ||
         data instanceof Float64Array);
 };
+export const getTagGroups = (tagGroups, tag) => {
+    const results = [];
+    const exact = tagGroups[tag];
+    if (exact)
+        results.push(exact);
+    let colonIdx = tag.lastIndexOf(':');
+    while (colonIdx !== -1) {
+        const parent = tag.slice(0, colonIdx);
+        const group = tagGroups[parent];
+        if (group)
+            results.push(group);
+        colonIdx = parent.lastIndexOf(':');
+    }
+    return results;
+};
 const EMPTY_ARRAY = Object.freeze([]);
 export const freezeDedupe = (arr) => {
     if (!arr || arr.length === 0)
@@ -61,16 +74,18 @@ const stopService = async (logger, name, service) => {
     }
 };
 /**
- * Stop all singleton services, including external package services.
- * External package services are stopped first, then the parent services.
+ * Stop all singleton services, including addon package services.
+ * Addon package services are stopped first, then the parent services.
  *
  * @param singletonServices - The parent singleton services to stop
  */
-export const stopSingletonServices = async (singletonServices) => {
+export const stopSingletonServices = async () => {
+    const singletonServices = getSingletonServices();
     const logger = singletonServices.logger;
-    // First, stop all external package singleton services
-    if (globalThis.pikkuState) {
-        for (const [packageName, packageState] of globalThis.pikkuState) {
+    // First, stop all addon package singleton services
+    const stateMap = getAllPackageStates();
+    if (stateMap.size > 0) {
+        for (const [packageName, packageState] of stateMap) {
             // Skip main package - we handle it separately
             if (packageName === '__main__')
                 continue;

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-assistant-ui.d.ts

@@ -0,0 +1,5 @@
+import type { AIStreamChannel, AIAgentInput } from './ai-agent.types.js';
+export declare function createAssistantUIChannel(parent: AIStreamChannel): AIStreamChannel;
+export declare function parseAssistantUIInput(input: Record<string, unknown>, defaults?: {
+    resourceId?: string;
+}): AIAgentInput;

package/dist/wirings/ai-agent/ai-agent-assistant-ui.js

@@ -0,0 +1,146 @@
+import { randomUUID } from 'crypto';
+export function createAssistantUIChannel(parent) {
+    const messageId = randomUUID();
+    let started = false;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let pendingToolResults = [];
+    let hasToolCalls = false;
+    let hasPendingApproval = false;
+    const sendChunk = (chunk) => {
+        parent.send(chunk);
+    };
+    const ensureStarted = () => {
+        if (!started) {
+            started = true;
+            sendChunk({ type: 'start', messageId });
+        }
+    };
+    const flushToolResults = () => {
+        for (const chunk of pendingToolResults) {
+            sendChunk(chunk);
+        }
+        pendingToolResults = [];
+    };
+    return {
+        channelId: parent.channelId,
+        openingData: parent.openingData,
+        get state() {
+            return parent.state;
+        },
+        close: () => parent.close(),
+        send: (event) => {
+            switch (event.type) {
+                case 'text-delta':
+                    ensureStarted();
+                    sendChunk({ type: 'text-delta', textDelta: event.text });
+                    break;
+                case 'reasoning-delta':
+                    ensureStarted();
+                    sendChunk({ type: 'reasoning-delta', delta: event.text });
+                    break;
+                case 'tool-call':
+                    ensureStarted();
+                    hasToolCalls = true;
+                    sendChunk({
+                        type: 'tool-call-start',
+                        id: event.toolCallId,
+                        toolCallId: event.toolCallId,
+                        toolName: event.toolName,
+                    });
+                    sendChunk({
+                        type: 'tool-call-delta',
+                        argsText: typeof event.args === 'string'
+                            ? event.args
+                            : JSON.stringify(event.args),
+                    });
+                    sendChunk({ type: 'tool-call-end' });
+                    break;
+                case 'tool-result':
+                    ensureStarted();
+                    pendingToolResults.push({
+                        type: 'tool-result',
+                        toolCallId: event.toolCallId,
+                        result: event.result,
+                    });
+                    break;
+                case 'agent-call':
+                case 'agent-result':
+                    break;
+                case 'usage': {
+                    ensureStarted();
+                    totalInputTokens += event.tokens.input;
+                    totalOutputTokens += event.tokens.output;
+                    const hasPending = pendingToolResults.length > 0;
+                    sendChunk({
+                        type: 'finish-step',
+                        finishReason: hasToolCalls ? 'tool-calls' : 'stop',
+                        usage: {
+                            promptTokens: event.tokens.input,
+                            completionTokens: event.tokens.output,
+                        },
+                        isContinued: hasPending,
+                    });
+                    flushToolResults();
+                    hasToolCalls = false;
+                    break;
+                }
+                case 'error':
+                    ensureStarted();
+                    sendChunk({ type: 'error', errorText: event.message });
+                    break;
+                case 'approval-request':
+                    ensureStarted();
+                    hasPendingApproval = true;
+                    sendChunk({ type: 'data-approval-request', data: event });
+                    break;
+                case 'suspended':
+                    ensureStarted();
+                    sendChunk({ type: 'data-suspended', data: event });
+                    break;
+                case 'done':
+                    ensureStarted();
+                    flushToolResults();
+                    sendChunk({
+                        type: 'finish',
+                        finishReason: hasPendingApproval ? 'tool-calls' : 'stop',
+                        usage: {
+                            promptTokens: totalInputTokens,
+                            completionTokens: totalOutputTokens,
+                        },
+                    });
+                    parent.send('[DONE]');
+                    parent.close();
+                    break;
+            }
+        },
+    };
+}
+export function parseAssistantUIInput(input, defaults) {
+    const messages = input.messages;
+    if (!messages || !Array.isArray(messages) || messages.length === 0) {
+        throw new Error('assistant-ui input must contain a non-empty messages array');
+    }
+    const lastUserMessage = [...messages].reverse().find((m) => m.role === 'user');
+    if (!lastUserMessage) {
+        throw new Error('No user message found in assistant-ui input');
+    }
+    let messageText;
+    if (typeof lastUserMessage.content === 'string') {
+        messageText = lastUserMessage.content;
+    }
+    else if (Array.isArray(lastUserMessage.parts)) {
+        const textPart = lastUserMessage.parts.find((p) => p.type === 'text');
+        messageText = textPart ? String(textPart.text) : '';
+    }
+    else if (Array.isArray(lastUserMessage.content)) {
+        const textPart = lastUserMessage.content.find((p) => p.type === 'text');
+        messageText = textPart ? String(textPart.text) : '';
+    }
+    else {
+        messageText = '';
+    }
+    const threadId = input.threadId ?? input.id ?? randomUUID();
+    const resourceId = defaults?.resourceId ?? 'default';
+    return { message: messageText, threadId, resourceId };
+}

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

@@ -0,0 +1,28 @@
+export declare function agent<TAgentMap extends Record<string, {
+    output: any;
+}>>(agentName: string & keyof TAgentMap): {
+    func: (services: any, data: any, wire: any) => Promise<any>;
+};
+export declare function agentStream<TAgentMap extends Record<string, {
+    output: any;
+}>>(agentName?: string & keyof TAgentMap): {
+    func: (services: any, data: any, wire: any) => Promise<void>;
+};
+export declare function agentResume(): {
+    func: (services: any, data: {
+        runId: string;
+        toolCallId: string;
+        approved: boolean;
+    }, wire: any) => Promise<void>;
+};
+export declare function agentApprove<TAgentMap extends Record<string, {
+    output: any;
+}>>(_agentName: string & keyof TAgentMap): {
+    func: (services: any, data: {
+        runId: string;
+        approvals: {
+            toolCallId: string;
+            approved: boolean;
+        }[];
+    }, wire: any) => Promise<any>;
+};

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

@@ -0,0 +1,40 @@
+export function agent(agentName) {
+    return {
+        func: async (_services, data, { rpc }) => {
+            return rpc.agent.run(agentName, data);
+        },
+    };
+}
+export function agentStream(agentName) {
+    return {
+        func: async (_services, data, { rpc }) => {
+            if (agentName) {
+                await rpc.agent.stream(agentName, data);
+            }
+            else {
+                const { agentName: name, ...rest } = data;
+                if (!name) {
+                    throw new Error('agentStream requires an agentName either as a parameter or in the input data');
+                }
+                await rpc.agent.stream(name, rest);
+            }
+        },
+    };
+}
+export function agentResume() {
+    return {
+        func: async (_services, data, { rpc }) => {
+            await rpc.agent.resume(data.runId, {
+                toolCallId: data.toolCallId,
+                approved: data.approved,
+            });
+        },
+    };
+}
+export function agentApprove(_agentName) {
+    return {
+        func: async (_services, data, { rpc }) => {
+            return rpc.agent.approve(data.runId, data.approvals);
+        },
+    };
+}

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,59 @@
+import type { CoreUserSession } from '../../types/core.types.js';
+import type { CoreAIAgent, AIAgentInput, AIAgentToolDef, AIMessage, AIStreamChannel, PikkuAIMiddlewareHooks } 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 = {
+    sessionService?: SessionService<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(params: RunAIAgentParams, agentSessionMap: Map<string, string>, resourceId: string, agentName: string, packageName: string | null, streamContext?: StreamContext, aiMiddlewares?: PikkuAIMiddlewareHooks[]): {
+    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;
+    maxSteps: number;
+    missingRpcs: string[];
+    workingMemoryJsonSchema: any;
+    workingMemorySchemaName: string | null;
+}>;