@pikku/core 0.12.20 → 0.12.22

package/dist/services/in-memory-workflow-service.js

@@ -16,6 +16,7 @@ import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service
  * ```
  */
 export class InMemoryWorkflowService extends PikkuWorkflowService {
+    sleepTimers = new Set();
     runs = new Map();
     steps = new Map(); // keyed by `${runId}:${stepName}`
     stepData = new Map(); // keyed by stepId
@@ -23,7 +24,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
     runState = new Map(); // keyed by runId
     branchKeys = new Map(); // keyed by stepId
     workflowVersions = new Map(); // keyed by `${name}:${graphHash}`
-    async createRun(workflowName, input, inline, graphHash, wire, options) {
+    async createRunImpl(workflowName, input, inline, graphHash, wire, options) {
         const runId = randomUUID();
         const now = new Date();
         const run = {
@@ -47,13 +48,26 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
         }
         return runId;
     }
+    async scheduleSleep(runId, stepId, duration) {
+        const timer = setTimeout(async () => {
+            this.sleepTimers.delete(timer);
+            try {
+                await this.executeWorkflowSleepCompleted(runId, stepId);
+            }
+            catch (error) {
+                this.logger?.error(`Failed to resume workflow sleep for runId ${runId}: ${error?.message ?? error}`);
+            }
+        }, duration);
+        this.sleepTimers.add(timer);
+        return true;
+    }
     async getRun(id) {
         return this.runs.get(id) || null;
     }
     async getRunHistory(runId) {
         return this.stepHistory.get(runId) || [];
     }
-    async updateRunStatus(id, status, output, error) {
+    async updateRunStatusImpl(id, status, output, error) {
         const run = this.runs.get(id);
         if (run) {
             run.status = status;
@@ -64,7 +78,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
                 run.error = error;
         }
     }
-    async insertStepState(runId, stepName, rpcName, data, stepOptions) {
+    async insertStepStateImpl(runId, stepName, rpcName, data, stepOptions) {
         const stepId = randomUUID();
         const now = new Date();
         const step = {
@@ -94,7 +108,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
         }
         return step;
     }
-    async setStepRunning(stepId) {
+    async setStepRunningImpl(stepId) {
         for (const step of this.steps.values()) {
             if (step.stepId === stepId) {
                 step.status = 'running';
@@ -104,7 +118,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             }
         }
     }
-    async setStepScheduled(stepId) {
+    async setStepScheduledImpl(stepId) {
         for (const step of this.steps.values()) {
             if (step.stepId === stepId) {
                 step.status = 'scheduled';
@@ -114,7 +128,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             }
         }
     }
-    async setStepResult(stepId, result) {
+    async setStepResultImpl(stepId, result) {
         for (const step of this.steps.values()) {
             if (step.stepId === stepId) {
                 step.status = 'succeeded';
@@ -125,7 +139,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             }
         }
     }
-    async setStepError(stepId, error) {
+    async setStepErrorImpl(stepId, error) {
         for (const step of this.steps.values()) {
             if (step.stepId === stepId) {
                 step.status = 'failed';
@@ -140,7 +154,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             }
         }
     }
-    async setStepChildRunId(stepId, childRunId) {
+    async setStepChildRunIdImpl(stepId, childRunId) {
         for (const step of this.steps.values()) {
             if (step.stepId === stepId) {
                 step.childRunId = childRunId;
@@ -149,7 +163,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             }
         }
     }
-    async createRetryAttempt(failedStepId, status) {
+    async createRetryAttemptImpl(failedStepId, status) {
         // Find the failed step
         let failedStep;
         let runId;
@@ -252,6 +266,10 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
         return fn();
     }
     async close() {
+        for (const timer of this.sleepTimers) {
+            clearTimeout(timer);
+        }
+        this.sleepTimers.clear();
         // Clear all in-memory state
         this.runs.clear();
         this.steps.clear();
@@ -317,10 +335,10 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             this.branchKeys.set(step.stepId, branchKey);
         }
     }
-    async setBranchTaken(stepId, branchKey) {
+    async setBranchTakenImpl(stepId, branchKey) {
         this.branchKeys.set(stepId, branchKey);
     }
-    async updateRunState(runId, name, value) {
+    async updateRunStateImpl(runId, name, value) {
         const state = this.runState.get(runId) || {};
         state[name] = value;
         this.runState.set(runId, state);
@@ -328,14 +346,14 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
     async getRunState(runId) {
         return this.runState.get(runId) || {};
     }
-    async upsertWorkflowVersion(name, graphHash, graph, source, status) {
+    async upsertWorkflowVersionImpl(name, graphHash, graph, source, status) {
         this.workflowVersions.set(`${name}:${graphHash}`, {
             graph,
             source,
             status: status ?? 'active',
         });
     }
-    async updateWorkflowVersionStatus(name, graphHash, status) {
+    async updateWorkflowVersionStatusImpl(name, graphHash, status) {
         const key = `${name}:${graphHash}`;
         const version = this.workflowVersions.get(key);
         if (version) {

package/dist/services/local-content.js

@@ -36,7 +36,14 @@ export class LocalContent {
         }
         if (this.jwt) {
             const expiresInSeconds = Math.max(1, Math.floor((expiresAt - signedAt) / 1000));
-            const signature = await this.jwt.encode({ value: expiresInSeconds, unit: 'second' }, { signedAt, expiresAt });
+            const payload = {
+                signedAt,
+                expiresAt,
+            };
+            if (dateGreaterThan) {
+                payload.notBefore = dateGreaterThan.getTime();
+            }
+            const signature = await this.jwt.encode({ value: expiresInSeconds, unit: 'second' }, payload);
             params.set('signature', signature);
         }
         return params.toString();

package/dist/services/user-session-service.d.ts

@@ -13,7 +13,7 @@ export declare class PikkuSessionService<UserSession extends CoreUserSession> im
     private sessionStore?;
     sessionChanged: boolean;
     initial: UserSession | undefined;
-    private session;
+    protected session: UserSession | undefined;
     private pikkuUserId?;
     constructor(sessionStore?: SessionStore<UserSession> | undefined);
     setPikkuUserId(id: string): void;

package/dist/testing/service-tests.js

@@ -49,6 +49,30 @@ export function defineServiceTests(config) {
             test('removeChannels with empty array is no-op', async () => {
                 await store.removeChannels([]);
             });
+            test('session round-trip — set / get / clear', async () => {
+                await store.addChannel({
+                    channelId: 'ch-state',
+                    channelName: 'test-channel',
+                });
+                // initially undefined
+                const empty = await store.getState('ch-state');
+                assert.equal(empty, undefined);
+                // set + get
+                const payload = { userId: 'u-7', meta: { foo: 1 } };
+                await store.setState('ch-state', payload);
+                const got = await store.getState('ch-state');
+                assert.deepEqual(got, payload);
+                // overwrite
+                const next = { userId: 'u-8' };
+                await store.setState('ch-state', next);
+                const got2 = await store.getState('ch-state');
+                assert.deepEqual(got2, next);
+                // clear
+                await store.clearState('ch-state');
+                const after = await store.getState('ch-state');
+                assert.equal(after, undefined);
+                await store.removeChannels(['ch-state']);
+            });
         });
     }
     if (services.eventHubStore) {

package/dist/types/core.types.d.ts

@@ -5,6 +5,7 @@ import type { SchemaService } from '../services/schema-service.js';
 import type { JWTService } from '../services/jwt-service.js';
 import type { PikkuHTTP } from '../wirings/http/http.types.js';
 import type { PikkuChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory } from '../wirings/channel/channel.types.js';
+import type { EventHubService } from '../wirings/channel/eventhub-service.js';
 import type { PikkuRPC } from '../wirings/rpc/rpc-types.js';
 import type { PikkuMCP } from '../wirings/mcp/mcp.types.js';
 import type { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js';
@@ -82,6 +83,7 @@ export type FunctionRuntimeMeta = {
     version?: number;
     approvalRequired?: boolean;
     approvalDescription?: string;
+    implementationHash?: string;
     contractHash?: string;
     inputHash?: string;
     outputHash?: string;
@@ -162,6 +164,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     workflowService?: WorkflowService;
     /** The queue service */
     queueService?: QueueService;
+    /** Event hub for realtime pub/sub across channels */
+    eventHub?: EventHubService<Record<string, any>>;
     /** The scheduler service */
     schedulerService?: SchedulerService;
     /** The deployment service for service discovery */

package/dist/types/state.types.d.ts

@@ -88,6 +88,7 @@ export interface PikkuPackageState {
     middleware: {
         tagGroup: Record<string, CorePikkuMiddlewareGroup>;
         httpGroup: Record<string, CorePikkuMiddlewareGroup>;
+        global: CorePikkuMiddlewareGroup;
     };
     channelMiddleware: {
         tagGroup: Record<string, CorePikkuChannelMiddleware[]>;
@@ -95,6 +96,7 @@ export interface PikkuPackageState {
     permissions: {
         tagGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
         httpGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
+        global: (CorePermissionGroup | CorePikkuPermission)[];
     };
     misc: {
         errors: Map<PikkuError, ErrorDetails>;
@@ -103,24 +105,6 @@ export interface PikkuPackageState {
         channelMiddleware: Record<string, CorePikkuChannelMiddleware[]>;
         permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
     };
-    models: {
-        config: {
-            models?: Record<string, string | {
-                model: string;
-                temperature?: number;
-                maxSteps?: number;
-            }>;
-            agentDefaults?: {
-                temperature?: number;
-                maxSteps?: number;
-            };
-            agentOverrides?: Record<string, {
-                model?: string;
-                temperature?: number;
-                maxSteps?: number;
-            }>;
-        } | null;
-    };
     package: {
         /** Service factory functions for addon packages */
         factories: {

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

@@ -3,14 +3,17 @@ import type { CoreAIAgent, AIAgentMemoryConfig, AIAgentInput, AIMessage } from '
 import type { AIStorageService } from '../../services/ai-storage-service.js';
 import type { Logger } from '../../services/logger.js';
 import type { SchemaService } from '../../services/schema-service.js';
+import type { PikkuAIMiddlewareHooks } from './ai-agent.types.js';
 export declare function resolveMemoryServices(agent: CoreAIAgent, singletonServices: CoreSingletonServices): {
     storage: AIStorageService | undefined;
 };
+export declare function isWorkingMemoryEnabled(memoryConfig: AIAgentMemoryConfig | undefined, storage: AIStorageService | undefined): boolean;
 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 | null | undefined, result: {
     text: string;
+    uiSpec?: unknown;
     steps: {
         toolCalls?: {
             name: string;
@@ -18,12 +21,28 @@ export declare function saveMessages(storage: AIStorageService | undefined, thre
             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;
+export declare function extractWorkingMemory(text: string): {
+    workingMemory: Record<string, unknown> | null;
+    cleanedText: string;
+};
+export declare function stripWorkingMemoryForStreaming(text: string): string;
+export declare function createWorkingMemoryMiddleware(options: {
+    storage?: AIStorageService;
+    threadId: string;
+    workingMemorySchemaName?: string | null;
+    logger?: Logger;
+    schemaService?: SchemaService;
+}): PikkuAIMiddlewareHooks<{
+    rawText?: string;
+    emittedVisibleText?: string;
+}>;
+export declare function getWorkingMemoryMiddleware(memoryConfig: AIAgentMemoryConfig | undefined, storage: AIStorageService | undefined, options: {
+    threadId: string;
+    workingMemorySchemaName?: string | null;
+    logger?: Logger;
+    schemaService?: SchemaService;
+}): PikkuAIMiddlewareHooks[];

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

@@ -6,9 +6,15 @@ export function resolveMemoryServices(agent, singletonServices) {
         : singletonServices.aiStorage;
     return { storage };
 }
+export function isWorkingMemoryEnabled(memoryConfig, storage) {
+    return !!memoryConfig?.workingMemory && !!storage;
+}
 export function deepMergeWorkingMemory(existing, updates) {
     const result = { ...existing };
     for (const key of Object.keys(updates)) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            continue;
+        }
         const value = updates[key];
         if (value === null) {
             delete result[key];
@@ -46,13 +52,18 @@ export function buildWorkingMemoryPrompt(currentState, jsonSchema) {
         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.');
+        'Only include durable facts you have actually derived or the user has confirmed. ' +
+        'Do not output templates, placeholders, or narration. ' +
+        'Only include changed fields. Leave unknown fields untouched. 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 workingMemoryStorage = isWorkingMemoryEnabled(memoryConfig, storage)
+        ? storage
+        : undefined;
+    if (workingMemoryStorage) {
+        const workingMem = await workingMemoryStorage.getWorkingMemory(input.threadId, 'thread');
         const prompt = buildWorkingMemoryPrompt(workingMem, workingMemoryJsonSchema);
         contextMessages.push({
             id: `wm-${randomUUID()}`,
@@ -63,8 +74,10 @@ export async function loadContextMessages(memoryConfig, storage, input, workingM
     }
     return contextMessages;
 }
-export async function saveMessages(storage, threadId, resourceId, memoryConfig, userMessage, result, options) {
-    let responseText = result.text;
+export async function saveMessages(storage, threadId, resourceId, memoryConfig, userMessage, result) {
+    const responseText = memoryConfig?.workingMemory
+        ? extractWorkingMemory(result.text).cleanedText
+        : result.text;
     if (storage) {
         const newMessages = userMessage ? [userMessage] : [];
         for (const step of result.steps) {
@@ -92,30 +105,21 @@ export async function saveMessages(storage, threadId, resourceId, memoryConfig,
                 });
             }
         }
+        const assistantContent = result.uiSpec != null
+            ? [
+                ...(responseText
+                    ? [{ type: 'text', text: responseText }]
+                    : []),
+                { type: 'generative-ui', spec: result.uiSpec },
+            ]
+            : responseText;
         newMessages.push({
             id: randomUUID(),
             role: 'assistant',
-            content: responseText,
+            content: assistantContent || undefined,
             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;
 }
@@ -209,3 +213,104 @@ export function parseWorkingMemory(text) {
 export function stripWorkingMemoryTags(text) {
     return text.replace(/<working_memory>[\s\S]*?<\/working_memory>/g, '').trim();
 }
+export function extractWorkingMemory(text) {
+    const workingMemory = parseWorkingMemory(text);
+    return {
+        workingMemory,
+        cleanedText: workingMemory ? stripWorkingMemoryTags(text) : text,
+    };
+}
+function getPendingWorkingMemoryPrefixLength(text) {
+    const prefixes = ['<working_memory>', '</working_memory>'];
+    const lastLt = text.lastIndexOf('<');
+    if (lastLt === -1)
+        return 0;
+    const suffix = text.slice(lastLt);
+    for (const prefix of prefixes) {
+        if (prefix.startsWith(suffix)) {
+            return suffix.length;
+        }
+    }
+    return 0;
+}
+export function stripWorkingMemoryForStreaming(text) {
+    let output = '';
+    let cursor = 0;
+    while (cursor < text.length) {
+        const openIndex = text.indexOf('<working_memory>', cursor);
+        if (openIndex === -1) {
+            const tail = text.slice(cursor);
+            const pendingPrefixLength = getPendingWorkingMemoryPrefixLength(tail);
+            output +=
+                pendingPrefixLength > 0 ? tail.slice(0, -pendingPrefixLength) : tail;
+            return output;
+        }
+        output += text.slice(cursor, openIndex);
+        const closeIndex = text.indexOf('</working_memory>', openIndex);
+        if (closeIndex === -1) {
+            return output;
+        }
+        cursor = closeIndex + '</working_memory>'.length;
+    }
+    return output;
+}
+export function createWorkingMemoryMiddleware(options) {
+    return {
+        modifyOutputStream: async (_services, { event, state }) => {
+            if (event.type !== 'text-delta')
+                return event;
+            const rawText = `${state.rawText ?? ''}${event.text}`;
+            state.rawText = rawText;
+            const visibleText = stripWorkingMemoryForStreaming(rawText);
+            const emittedVisibleText = state.emittedVisibleText ?? '';
+            if (!visibleText.startsWith(emittedVisibleText)) {
+                state.emittedVisibleText = visibleText;
+                return { ...event, text: visibleText };
+            }
+            const delta = visibleText.slice(emittedVisibleText.length);
+            state.emittedVisibleText = visibleText;
+            if (!delta)
+                return null;
+            return { ...event, text: delta };
+        },
+        modifyOutput: async (_services, { text, messages, usage }) => {
+            const { workingMemory, cleanedText } = extractWorkingMemory(text);
+            if (workingMemory && options.storage) {
+                const existing = (await options.storage.getWorkingMemory(options.threadId, 'thread')) ?? {};
+                const merged = deepMergeWorkingMemory(existing, workingMemory);
+                let valid = true;
+                if (options.schemaService && options.workingMemorySchemaName) {
+                    try {
+                        await options.schemaService.validateSchema(options.workingMemorySchemaName, merged);
+                    }
+                    catch (err) {
+                        valid = false;
+                        options.logger?.warn(`Working memory validation failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+                // Only persist when the merged value passes schema validation —
+                // saving invalid data would poison subsequent getWorkingMemory reads.
+                if (valid) {
+                    await options.storage.saveWorkingMemory(options.threadId, 'thread', merged);
+                }
+            }
+            return {
+                text: cleanedText,
+                messages,
+            };
+        },
+    };
+}
+export function getWorkingMemoryMiddleware(memoryConfig, storage, options) {
+    if (!isWorkingMemoryEnabled(memoryConfig, storage))
+        return [];
+    return [
+        createWorkingMemoryMiddleware({
+            storage,
+            threadId: options.threadId,
+            workingMemorySchemaName: options.workingMemorySchemaName,
+            logger: options.logger,
+            schemaService: options.schemaService,
+        }),
+    ];
+}

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

@@ -1,4 +1,13 @@
-export declare function resolveModelConfig(agentName: string, agent: {
+/**
+ * Resolves the effective model/temperature/maxSteps for an agent at runtime.
+ *
+ * Models are declared per-agent using the provider-qualified `provider/model`
+ * form (e.g. `openai/gpt-5-mini`); there is no config-level alias map. This
+ * function remains the single merge point for request-time overrides (see
+ * ai-agent-prepare's `input.model`), so callers stay decoupled from how the
+ * effective config is assembled.
+ */
+export declare function resolveModelConfig(_agentName: string, agent: {
     model: string;
     temperature?: number;
     maxSteps?: number;

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

@@ -1,36 +1,16 @@
-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 };
+/**
+ * Resolves the effective model/temperature/maxSteps for an agent at runtime.
+ *
+ * Models are declared per-agent using the provider-qualified `provider/model`
+ * form (e.g. `openai/gpt-5-mini`); there is no config-level alias map. This
+ * function remains the single merge point for request-time overrides (see
+ * ai-agent-prepare's `input.model`), so callers stay decoupled from how the
+ * effective config is assembled.
+ */
+export function resolveModelConfig(_agentName, agent) {
+    return {
+        model: agent.model,
+        temperature: agent.temperature,
+        maxSteps: agent.maxSteps,
+    };
 }

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

@@ -169,6 +169,9 @@ export function createScopedChannel(parent, agentName, session) {
                 parent.send(event);
             }
         },
+        setState: (s) => parent.setState(s),
+        getState: () => parent.getState(),
+        clearState: () => parent.clearState(),
     };
 }
 export async function buildToolDefs(params, agentSessionMap, resourceId, agentName, packageName, streamContext, aiMiddlewares, agentMode) {
@@ -254,7 +257,7 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                 }
             }
             tools.push({
-                name: toolName.replaceAll(':', '__'),
+                name: toolName.replaceAll('@', '_').replaceAll(':', '__'),
                 description: fnMeta?.description || fnMeta?.title || toolName,
                 inputSchema,
                 needsApproval: needsApproval || undefined,