@pikku/core 0.12.0 → 0.12.2

package/dist/services/workflow-service.d.ts

@@ -1,5 +1,5 @@
-import { SerializedError, CoreSingletonServices, CreateWireServices, CoreConfig } from '../types/core.types.js';
-import { WorkflowRun, WorkflowRunWire, StepState, WorkflowStatus } from '../wirings/workflow/workflow.types.js';
+import type { SerializedError } from '../types/core.types.js';
+import type { WorkflowRun, WorkflowRunWire, StepState, WorkflowStatus } from '../wirings/workflow/workflow.types.js';
 /**
  * Interface for workflow orchestration
  * Handles workflow execution, replay, orchestration logic, and run-level state
@@ -14,7 +14,6 @@ export interface WorkflowService {
     withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>;
     close(): Promise<void>;
     resumeWorkflow(runId: string): Promise<void>;
-    setServices(singletonServices: CoreSingletonServices, createWireServices: CreateWireServices | undefined, config: CoreConfig): void;
     startWorkflow<I>(name: string, input: I, wire: WorkflowRunWire, rpcService: any, options?: {
         inline?: boolean;
         startNode?: string;

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

@@ -1,25 +1,27 @@
 import type { Logger, LogLevel } from '../services/logger.js';
-import { VariablesService } from '../services/variables-service.js';
-import { SecretService } from '../services/secret-service.js';
-import { SchemaService } from '../services/schema-service.js';
-import { JWTService } from '../services/jwt-service.js';
-import { PikkuHTTP } from '../wirings/http/http.types.js';
-import { PikkuChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory } from '../wirings/channel/channel.types.js';
-import { PikkuRPC } from '../wirings/rpc/rpc-types.js';
-import { PikkuMCP } from '../wirings/mcp/mcp.types.js';
-import { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js';
-import { PikkuQueue, QueueService } from '../wirings/queue/queue.types.js';
-import { PikkuCLI } from '../wirings/cli/cli.types.js';
-import { PikkuWorkflowWire, WorkflowService, WorkflowServiceConfig, WorkflowStepWire } from '../wirings/workflow/workflow.types.js';
+import type { VariablesService } from '../services/variables-service.js';
+import type { SecretService } from '../services/secret-service.js';
+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 { 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';
+import type { PikkuQueue, QueueService } from '../wirings/queue/queue.types.js';
+import type { PikkuCLI } from '../wirings/cli/cli.types.js';
+import type { PikkuWorkflowWire, WorkflowService, WorkflowServiceConfig, WorkflowStepWire } from '../wirings/workflow/workflow.types.js';
 import type { PikkuGraphWire } from '../wirings/workflow/graph/workflow-graph.types.js';
-import { PikkuTrigger } from '../wirings/trigger/trigger.types.js';
-import { SchedulerService } from '../services/scheduler-service.js';
-import { DeploymentService } from '../services/deployment-service.js';
-import { AIStorageService } from '../services/ai-storage-service.js';
-import { AIAgentRunnerService } from '../services/ai-agent-runner-service.js';
-import { AIRunStateService } from '../services/ai-run-state-service.js';
+import type { PikkuTrigger } from '../wirings/trigger/trigger.types.js';
+import type { PikkuGateway } from '../wirings/gateway/gateway.types.js';
+import type { SchedulerService } from '../services/scheduler-service.js';
+import type { DeploymentService } from '../services/deployment-service.js';
+import type { AIStorageService } from '../services/ai-storage-service.js';
+import type { ContentService } from '../services/content-service.js';
+import type { AIAgentRunnerService } from '../services/ai-agent-runner-service.js';
+import type { AIRunStateService } from '../services/ai-run-state-service.js';
 import type { PikkuAIMiddlewareHooks } from '../wirings/ai-agent/ai-agent.types.js';
-export type PikkuWiringTypes = 'http' | 'scheduler' | 'trigger' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow' | 'agent';
+export type PikkuWiringTypes = 'http' | 'scheduler' | 'trigger' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow' | 'agent' | 'gateway';
 export interface FunctionServicesMeta {
     optimized: boolean;
     services: string[];
@@ -69,10 +71,13 @@ export type FunctionRuntimeMeta = {
     expose?: boolean;
     remote?: boolean;
     mcp?: boolean;
+    readonly?: boolean;
     sessionless?: boolean;
     version?: number;
     requiresApproval?: boolean;
     contractHash?: string;
+    inputHash?: string;
+    outputHash?: string;
 };
 export type FunctionMeta = FunctionRuntimeMeta & Partial<{
     name: string;
@@ -154,6 +159,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     deploymentService?: DeploymentService;
     /** AI agent storage service (threads, messages, working memory) */
     aiStorage?: AIStorageService;
+    /** Content service for file storage and retrieval */
+    content?: ContentService;
     /** AI agent runner service (model calls + tool loop) */
     aiAgentRunner?: AIAgentRunnerService;
     /** AI run state service (run lifecycle + approval persistence) */
@@ -176,6 +183,7 @@ export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boo
     workflowStep: WorkflowStepWire;
     graph: PikkuGraphWire;
     trigger: PikkuTrigger<TriggerOutput>;
+    gateway: PikkuGateway;
     session: HasInitialSession extends true ? UserSession : UserSession | undefined;
     /** Update and persist the current session */
     setSession: (session: CoreUserSession) => Promise<void> | void;

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

@@ -1,16 +1,17 @@
-import { PikkuError, ErrorDetails } from '../errors/error-handler.js';
-import { CorePikkuFunctionConfig, CorePermissionGroup, CorePikkuPermission } from '../function/functions.types.js';
-import { CorePikkuTriggerFunctionConfig } from '../wirings/trigger/trigger.types.js';
-import { CoreChannel, ChannelsMeta } from '../wirings/channel/channel.types.js';
-import { CLIMeta, CLIProgramState } from '../wirings/cli/cli.types.js';
-import { HTTPMethod, CoreHTTPFunctionWiring, HTTPWiringsMeta } from '../wirings/http/http.types.js';
-import { CoreMCPResource, MCPResourceMeta, MCPToolMeta, CoreMCPPrompt, MCPPromptMeta } from '../wirings/mcp/mcp.types.js';
-import { CoreAIAgent, AIAgentMeta } from '../wirings/ai-agent/ai-agent.types.js';
-import { CoreQueueWorker, QueueWorkersMeta } from '../wirings/queue/queue.types.js';
-import { CoreScheduledTask, ScheduledTasksMeta } from '../wirings/scheduler/scheduler.types.js';
-import { CoreWorkflow, WorkflowsRuntimeMeta } from '../wirings/workflow/workflow.types.js';
-import { CoreTrigger, CoreTriggerSource, TriggerMeta, TriggerSourceMeta } from '../wirings/trigger/trigger.types.js';
-import { FunctionsMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, CreateConfig, CreateSingletonServices, CreateWireServices, CoreConfig, CoreSingletonServices, CoreServices, CoreUserSession } from './core.types.js';
+import type { PikkuError, ErrorDetails } from '../errors/error-handler.js';
+import type { CorePikkuFunctionConfig, CorePermissionGroup, CorePikkuPermission } from '../function/functions.types.js';
+import type { CorePikkuTriggerFunctionConfig } from '../wirings/trigger/trigger.types.js';
+import type { CoreChannel, ChannelsMeta } from '../wirings/channel/channel.types.js';
+import type { CLIMeta, CLIProgramState } from '../wirings/cli/cli.types.js';
+import type { HTTPMethod, CoreHTTPFunctionWiring, HTTPWiringsMeta } from '../wirings/http/http.types.js';
+import type { CoreMCPResource, MCPResourceMeta, MCPToolMeta, CoreMCPPrompt, MCPPromptMeta } from '../wirings/mcp/mcp.types.js';
+import type { CoreAIAgent, AIAgentMeta } from '../wirings/ai-agent/ai-agent.types.js';
+import type { CoreGateway, GatewaysMeta } from '../wirings/gateway/gateway.types.js';
+import type { CoreQueueWorker, QueueWorkersMeta } from '../wirings/queue/queue.types.js';
+import type { CoreScheduledTask, ScheduledTasksMeta } from '../wirings/scheduler/scheduler.types.js';
+import type { CoreWorkflow, WorkflowsRuntimeMeta } from '../wirings/workflow/workflow.types.js';
+import type { CoreTrigger, CoreTriggerSource, TriggerMeta, TriggerSourceMeta } from '../wirings/trigger/trigger.types.js';
+import type { FunctionsMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, CreateConfig, CreateSingletonServices, CreateWireServices, CoreConfig, CoreSingletonServices, CoreServices, CoreUserSession } from './core.types.js';
 import type { CorePikkuChannelMiddleware } from '../wirings/channel/channel.types.js';
 /**
  * State structure for an individual package
@@ -27,9 +28,11 @@ export interface PikkuPackageState {
             path: string;
         }>;
         /** Maps namespace aliases to package config (e.g., 'ext' -> { package: '@pikku/...', rpcEndpoint: '...' }) */
-        externalPackages: Map<string, {
+        addons: Map<string, {
             package: string;
             rpcEndpoint?: string;
+            auth?: boolean;
+            tags?: string[];
         }>;
     };
     http: {
@@ -72,6 +75,10 @@ export interface PikkuPackageState {
         agents: Map<string, CoreAIAgent>;
         agentsMeta: AIAgentMeta;
     };
+    gateway: {
+        gateways: Map<string, CoreGateway>;
+        meta: GatewaysMeta;
+    };
     cli: {
         meta: CLIMeta | Record<string, any>;
         programs: Record<string, CLIProgramState>;
@@ -113,7 +120,7 @@ export interface PikkuPackageState {
         } | null;
     };
     package: {
-        /** Service factory functions for external packages */
+        /** Service factory functions for addon packages */
         factories: {
             createConfig?: CreateConfig<CoreConfig>;
             createSingletonServices?: CreateSingletonServices<CoreConfig, CoreSingletonServices>;

package/dist/utils.d.ts

@@ -1,14 +1,14 @@
-import { Logger } from './services/logger.js';
-import { CoreSingletonServices, WireServices } from './types/core.types.js';
+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,3 +1,4 @@
+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) {
@@ -10,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 ||
@@ -73,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) {
+    // 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/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,168 @@
+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(),
+        sendBinary: (data) => parent.sendBinary(data),
+        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 'audio-delta':
+                    ensureStarted();
+                    sendChunk({ type: 'audio-delta', data: event });
+                    break;
+                case 'audio-done':
+                    ensureStarted();
+                    sendChunk({ type: 'audio-done', data: event });
+                    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;
+    let attachments;
+    const extractFromParts = (parts) => {
+        const textParts = parts.filter((p) => p.type === 'text');
+        messageText = textParts.map((p) => String(p.text)).join(' ') || '';
+        const nonTextParts = parts.filter((p) => p.type === 'image' || p.type === 'file');
+        if (nonTextParts.length > 0) {
+            attachments = nonTextParts.map((p) => ({
+                type: p.type,
+                data: p.data,
+                url: p.url,
+                mediaType: p.mediaType,
+                filename: p.filename,
+            }));
+        }
+    };
+    if (typeof lastUserMessage.content === 'string') {
+        messageText = lastUserMessage.content;
+    }
+    else if (Array.isArray(lastUserMessage.parts)) {
+        extractFromParts(lastUserMessage.parts);
+    }
+    else if (Array.isArray(lastUserMessage.content)) {
+        extractFromParts(lastUserMessage.content);
+    }
+    else {
+        messageText = '';
+    }
+    const threadId = input.threadId ?? input.id ?? randomUUID();
+    const resourceId = defaults?.resourceId ?? 'default';
+    return { message: messageText, threadId, resourceId, attachments };
+}

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.js

@@ -175,8 +175,19 @@ function sanitizeToolMessages(messages) {
 }
 function estimateTokens(msg) {
     let chars = 0;
-    if (msg.content)
-        chars += msg.content.length;
+    if (msg.content) {
+        if (typeof msg.content === 'string') {
+            chars += msg.content.length;
+        }
+        else {
+            for (const part of msg.content) {
+                if (part.type === 'text')
+                    chars += part.text.length;
+                else
+                    chars += 1000;
+            }
+        }
+    }
     if (msg.toolCalls)
         chars += JSON.stringify(msg.toolCalls).length;
     if (msg.toolResults)

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

@@ -1,12 +1,10 @@
-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 { 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 = {
-    singletonServices: CoreSingletonServices;
     sessionService?: SessionService<CoreUserSession>;
-    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export type StreamAIAgentOptions = {
     requiresToolApproval?: 'all' | 'explicit' | false;
@@ -40,7 +38,7 @@ export type ScopedChannel = AIStreamChannel & {
     } | 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): {
+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[];
 };
@@ -54,6 +52,7 @@ export declare function prepareAgentRun(agentName: string, input: AIAgentInput,
     threadId: string;
     userMessage: AIMessage;
     runnerParams: AIAgentRunnerParams;
+    maxSteps: number;
     missingRpcs: string[];
     workingMemoryJsonSchema: any;
     workingMemorySchemaName: string | null;