@pikku/inspector 0.12.59 → 0.12.60

package/CHANGELOG.md

@@ -1,3 +1,75 @@
+## 0.12.60
+
+### Patch Changes
+
+- 7406bfe: Rename the agent runtime from `AI*` to `Agent*` (#596)
+
+  `AI` described the model provider, not the thing being named. Every symbol that
+  belongs to the agent runtime now says `Agent`; the symbols that genuinely wrap a
+  model provider — `AIEmbeddingService`, `AIProviderOptions`, `AIEmbedParams`,
+  `AITranscriptionParams`, `AIGenerateImageParams` and their siblings, and the
+  `@pikku/ai-vercel` / `@pikku/ai-deepinfra` / `@pikku/ai-voice` packages — keep
+  their names.
+
+  **Wiring**
+  - `pikkuAIAgent` → `pikkuAgent`, `pikkuAIScorer` → `pikkuAgentScorer`,
+    `pikkuAIJudge` → `pikkuAgentJudge`
+  - `CoreAIAgent` → `CoreAgent`, `AIAgentInput` → `AgentInput`, `AIAgentStep` →
+    `AgentStep`, `AIMessage` → `AgentMessage`, and the rest of the agent types
+  - `AIAgentRunnerService` → `AgentRunnerService`, `AIStorageService` →
+    `AgentStorageService`, `AIRunStateService` → `AgentRunStateService`
+
+  **Entry points**
+
+  `@pikku/core/agent` → `@pikku/core/agent`, `@pikku/core/agent-scorer` →
+  `@pikku/core/agent-scorer`.
+
+  **Queues**
+
+  The scorer queues are now `agent-score-fast` and `agent-score-slow`. Drain the
+  old `ai-score-fast` / `ai-score-slow` queues before deploying — jobs still
+  sitting on them when the new workers start will never be picked up.
+
+  **Scaffolds**
+
+  The agent scaffold pikku wrote for your project — `<scaffold>/agent/agent.gen.ts`
+  and its schemas file — imports `@pikku/core/ai-agent`, which no longer exists. A
+  scaffold is normally written once and then left alone, so `pikku all` would find
+  it present and leave the broken import in place. It now deletes an agent scaffold
+  importing either removed entry point and regenerates it in the same run. Anything
+  you added to that file goes with it, so move local edits out first.
+
+  **Database**
+
+  The agent tables are renamed: `ai_threads`, `ai_message`, `ai_tool_call`,
+  `ai_working_memory`, `ai_run` and `ai_run_score` become `agent_threads`,
+  `agent_message`, `agent_tool_call`, `agent_working_memory`, `agent_run` and
+  `agent_run_score`, along with their indexes and the `ai_working_memory_pk`
+  constraint. The same rename applies to the MongoDB collections.
+
+  `ensurePikkuSchema` creates tables it cannot find, so an existing database will
+  get empty `agent_*` tables and leave the old data stranded in `ai_*`. Rename
+  them before the first boot on the new version:
+
+  ```sql
+  ALTER TABLE ai_threads        RENAME TO agent_threads;
+  ALTER TABLE ai_message        RENAME TO agent_message;
+  ALTER TABLE ai_tool_call      RENAME TO agent_tool_call;
+  ALTER TABLE ai_working_memory RENAME TO agent_working_memory;
+  ALTER TABLE ai_run            RENAME TO agent_run;
+  ALTER TABLE ai_run_score      RENAME TO agent_run_score;
+  ```
+
+- 6794681: Publish the ecosystem surface as per-area sub-barrels under `@pikku/core/ecosystem/*`, and point generated code, the CLI, the inspector and the runtime adapters at them.
+
+  348 names that only generated code, the toolchain or a runtime adapter ever imports now have a second home on `@pikku/core/ecosystem/<area>` — one sub-barrel per area, matching how core already publishes its entrypoints, so no single barrel grows without bound and a consumer only pulls in the area it uses.
+
+  This step is additive: every name is still exported from the entrypoint it was published from before, so nothing downstream breaks. Removing them from the app-facing barrels is a later change, and needs a release carrying `./ecosystem/*` first.
+
+- Updated dependencies [7406bfe]
+- Updated dependencies [6794681]
+  - @pikku/core@0.12.84
+
 ## 0.12.59
 
 ### Patch Changes

package/dist/add/add-agent-scorer.d.ts

@@ -0,0 +1,2 @@
+import type { AddWiring } from '../types.js';
+export declare const addAgentScorer: AddWiring;

package/dist/add/add-agent-scorer.js

@@ -0,0 +1,61 @@
+import * as ts from 'typescript';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { ErrorCode } from '../error-codes.js';
+/**
+ * `pikkuAgentScorer` grades in code and `pikkuAgentJudge` grades with a model, which
+ * is the whole difference between the two lanes — so the lane is read off which
+ * constructor was called rather than from a field an author could contradict.
+ */
+const LANES = {
+    pikkuAgentScorer: 'fast',
+    pikkuAgentJudge: 'slow',
+};
+export const addAgentScorer = (logger, node, checker, state) => {
+    if (!ts.isCallExpression(node))
+        return;
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression))
+        return;
+    const lane = LANES[expression.text];
+    if (!lane)
+        return;
+    const firstArg = node.arguments[0];
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+        return;
+    const obj = firstArg;
+    const { exportedName } = extractFunctionName(node, checker, state.rootDir);
+    const nameValue = getPropertyValue(obj, 'name');
+    if (!nameValue) {
+        logger.critical(ErrorCode.MISSING_NAME, "AI scorer is missing the required 'name' property.");
+        return;
+    }
+    const description = getPropertyValue(obj, 'description');
+    if (!description) {
+        logger.critical(ErrorCode.MISSING_DESCRIPTION, `AI scorer '${nameValue}' is missing the required 'description' property.`);
+        return;
+    }
+    const sampleRateValue = getPropertyValue(obj, 'sampleRate');
+    if (sampleRateValue !== null &&
+        (sampleRateValue < 0 || sampleRateValue > 1)) {
+        logger.critical(ErrorCode.INVALID_VALUE, `AI scorer '${nameValue}' has a sampleRate of ${sampleRateValue} — it is the fraction of live runs to grade, so it must be between 0 and 1.`);
+        return;
+    }
+    const requiresReference = getPropertyValue(obj, 'requiresReference') ?? false;
+    const scorerKey = exportedName || nameValue;
+    if (exportedName) {
+        state.scorers.files.set(scorerKey, {
+            path: node.getSourceFile().fileName,
+            exportedName,
+        });
+    }
+    state.scorers.scorersMeta[scorerKey] = {
+        name: nameValue,
+        description,
+        lane,
+        sampleRate: sampleRateValue ?? 1,
+        requiresReference,
+        sourceFile: node.getSourceFile().fileName,
+        exportedName: exportedName || undefined,
+    };
+};

package/dist/add/add-agent.d.ts

@@ -0,0 +1,4 @@
+import * as ts from 'typescript';
+import type { AddWiring, InspectorLogger } from '../types.js';
+export declare function resolveWorkflowReferences(obj: ts.ObjectLiteralExpression, checker: ts.TypeChecker, agentName: string, logger: InspectorLogger): string[] | null;
+export declare const addAgent: AddWiring;

package/dist/add/add-agent.js

@@ -0,0 +1,442 @@
+import * as ts from 'typescript';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { extractFunctionName, funcIdToTypeName, } from '../utils/extract-function-name.js';
+import { resolveMiddleware, resolveChannelMiddleware, resolveAgentMiddleware, } from '../utils/middleware.js';
+import { resolvePermissions } from '../utils/permissions.js';
+import { ErrorCode } from '../error-codes.js';
+import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
+function resolveToolReferences(obj, checker, agentName, logger) {
+    const property = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'tools');
+    if (!property || !ts.isPropertyAssignment(property)) {
+        return null;
+    }
+    const initializer = property.initializer;
+    if (!ts.isArrayLiteralExpression(initializer)) {
+        return null;
+    }
+    const resolved = [];
+    for (const element of initializer.elements) {
+        if (ts.isStringLiteral(element)) {
+            logger.critical(ErrorCode.INVALID_VALUE, `AI agent '${agentName}' tools array contains a string literal '${element.text}'. ` +
+                `Use a function reference instead (e.g., import the pikkuFunc variable).`);
+            continue;
+        }
+        if (ts.isCallExpression(element) && ts.isIdentifier(element.expression)) {
+            const calleeName = element.expression.text;
+            if (calleeName === 'workflow') {
+                const [firstArg] = element.arguments;
+                if (firstArg && ts.isStringLiteral(firstArg)) {
+                    resolved.push(`workflow:${firstArg.text}`);
+                    continue;
+                }
+            }
+            if (calleeName === 'ref') {
+                const [firstArg] = element.arguments;
+                if (firstArg && ts.isStringLiteral(firstArg)) {
+                    resolved.push(firstArg.text);
+                    continue;
+                }
+            }
+        }
+        if (ts.isIdentifier(element)) {
+            const rpcName = resolveIdentifierToRpcName(element, checker);
+            if (rpcName) {
+                resolved.push(rpcName);
+                continue;
+            }
+            logger.critical(ErrorCode.INVALID_VALUE, `AI agent '${agentName}' tools array contains identifier '${element.text}' ` +
+                `that could not be resolved to a pikkuFunc.`);
+        }
+    }
+    return resolved.length > 0 ? resolved : null;
+}
+function resolveAgentReferences(obj, checker, agentName, logger) {
+    const property = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'agents');
+    if (!property || !ts.isPropertyAssignment(property)) {
+        return null;
+    }
+    const initializer = property.initializer;
+    if (!ts.isArrayLiteralExpression(initializer)) {
+        return null;
+    }
+    const resolved = [];
+    for (const element of initializer.elements) {
+        if (ts.isStringLiteral(element)) {
+            logger.critical(ErrorCode.INVALID_VALUE, `AI agent '${agentName}' agents array contains a string literal '${element.text}'. ` +
+                `Use an agent reference instead (e.g., import the pikkuAgent variable).`);
+            continue;
+        }
+        if (ts.isIdentifier(element)) {
+            const name = resolveIdentifierToAgentName(element, checker);
+            if (name) {
+                resolved.push(name);
+                continue;
+            }
+            logger.critical(ErrorCode.INVALID_VALUE, `AI agent '${agentName}' agents array contains identifier '${element.text}' ` +
+                `that could not be resolved to a pikkuAgent.`);
+        }
+    }
+    return resolved.length > 0 ? resolved : null;
+}
+export function resolveWorkflowReferences(obj, checker, agentName, logger) {
+    const property = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'workflows');
+    if (!property || !ts.isPropertyAssignment(property)) {
+        return null;
+    }
+    const initializer = property.initializer;
+    if (!ts.isArrayLiteralExpression(initializer)) {
+        return null;
+    }
+    const resolved = [];
+    for (const element of initializer.elements) {
+        if (ts.isStringLiteral(element)) {
+            logger.critical(ErrorCode.INVALID_VALUE, `AI agent '${agentName}' workflows array contains a string literal '${element.text}'. ` +
+                `Use a workflow reference instead (e.g., ref('<workflowName>') or import the pikkuWorkflowGraph variable).`);
+            continue;
+        }
+        if (ts.isCallExpression(element) && ts.isIdentifier(element.expression)) {
+            const calleeName = element.expression.text;
+            if (calleeName === 'ref' || calleeName === 'workflow') {
+                const [firstArg] = element.arguments;
+                if (firstArg && ts.isStringLiteral(firstArg)) {
+                    resolved.push(firstArg.text);
+                    continue;
+                }
+            }
+        }
+        if (ts.isIdentifier(element)) {
+            const name = resolveIdentifierToWorkflowName(element, checker);
+            if (name) {
+                resolved.push(name);
+                continue;
+            }
+            logger.critical(ErrorCode.INVALID_VALUE, `AI agent '${agentName}' workflows array contains identifier '${element.text}' ` +
+                `that could not be resolved to a pikkuWorkflowGraph.`);
+        }
+    }
+    return resolved.length > 0 ? resolved : null;
+}
+function resolveIdentifierToWorkflowName(identifier, checker) {
+    const symbol = checker.getSymbolAtLocation(identifier);
+    if (!symbol)
+        return null;
+    let resolved = symbol;
+    if (resolved.flags & ts.SymbolFlags.Alias) {
+        resolved = checker.getAliasedSymbol(resolved) ?? resolved;
+    }
+    const decl = resolved.valueDeclaration ?? resolved.declarations?.[0];
+    if (!decl)
+        return null;
+    if (ts.isVariableDeclaration(decl) && decl.initializer) {
+        if (ts.isCallExpression(decl.initializer) &&
+            ts.isIdentifier(decl.initializer.expression) &&
+            (decl.initializer.expression.text === 'pikkuWorkflowGraph' ||
+                decl.initializer.expression.text === 'pikkuWorkflow' ||
+                decl.initializer.expression.text === 'pikkuWorkflowComplex')) {
+            const firstArg = decl.initializer.arguments[0];
+            if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+                for (const prop of firstArg.properties) {
+                    if (ts.isPropertyAssignment(prop) &&
+                        ts.isIdentifier(prop.name) &&
+                        prop.name.text === 'name' &&
+                        ts.isStringLiteral(prop.initializer)) {
+                        return prop.initializer.text;
+                    }
+                }
+            }
+            if (ts.isIdentifier(decl.name)) {
+                return decl.name.text;
+            }
+        }
+    }
+    return null;
+}
+function resolveIdentifierToRpcName(identifier, checker) {
+    const symbol = checker.getSymbolAtLocation(identifier);
+    if (!symbol)
+        return null;
+    let resolved = symbol;
+    if (resolved.flags & ts.SymbolFlags.Alias) {
+        resolved = checker.getAliasedSymbol(resolved) ?? resolved;
+    }
+    const decl = resolved.valueDeclaration ?? resolved.declarations?.[0];
+    if (!decl)
+        return null;
+    if (ts.isVariableDeclaration(decl) && decl.initializer) {
+        if (ts.isCallExpression(decl.initializer) &&
+            ts.isIdentifier(decl.initializer.expression)) {
+            const callName = decl.initializer.expression.text;
+            if (callName === 'pikkuFunc' ||
+                callName === 'pikkuSessionlessFunc' ||
+                callName === 'pikkuVoidFunc') {
+                const firstArg = decl.initializer.arguments[0];
+                if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+                    for (const prop of firstArg.properties) {
+                        if (ts.isPropertyAssignment(prop) &&
+                            ts.isIdentifier(prop.name) &&
+                            prop.name.text === 'override' &&
+                            ts.isStringLiteral(prop.initializer)) {
+                            return prop.initializer.text;
+                        }
+                    }
+                }
+                if (ts.isIdentifier(decl.name)) {
+                    return decl.name.text;
+                }
+            }
+        }
+    }
+    return null;
+}
+function resolveIdentifierToAgentName(identifier, checker) {
+    const symbol = checker.getSymbolAtLocation(identifier);
+    if (!symbol)
+        return null;
+    let resolved = symbol;
+    if (resolved.flags & ts.SymbolFlags.Alias) {
+        resolved = checker.getAliasedSymbol(resolved) ?? resolved;
+    }
+    const decl = resolved.valueDeclaration ?? resolved.declarations?.[0];
+    if (!decl)
+        return null;
+    if (ts.isVariableDeclaration(decl) && decl.initializer) {
+        if (ts.isCallExpression(decl.initializer) &&
+            ts.isIdentifier(decl.initializer.expression) &&
+            decl.initializer.expression.text === 'pikkuAgent') {
+            if (ts.isIdentifier(decl.name)) {
+                return decl.name.text;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * The scorers an agent asks to be graded by, which are plain names rather than
+ * references: a scorer is resolved out of the registry at grading time, not
+ * imported by the agent, so nothing here has a declaration to chase.
+ */
+function resolveScorerNames(obj, agentName, logger) {
+    const property = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.text === 'scorers');
+    if (!property || !ts.isPropertyAssignment(property))
+        return null;
+    if (!ts.isArrayLiteralExpression(property.initializer))
+        return null;
+    const names = [];
+    for (const element of property.initializer.elements) {
+        if (!ts.isStringLiteral(element)) {
+            logger.critical(ErrorCode.INVALID_VALUE, `AI agent '${agentName}' lists a scorer that is not an inline string: \`${element.getText()}\`. A scorer is named, not imported, so the name has to be readable from source.`);
+            continue;
+        }
+        names.push(element.text);
+    }
+    return names.length > 0 ? names : null;
+}
+export const addAgent = (logger, node, checker, state, options) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression) || expression.text !== 'pikkuAgent') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    const { exportedName } = extractFunctionName(node, checker, state.rootDir);
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const nameValue = getPropertyValue(obj, 'name');
+        const { disabled, tags, summary, description, errors } = getCommonWireMetaData(obj, 'AI agent', nameValue, logger, checker);
+        if (disabled)
+            return;
+        const modelValue = getPropertyValue(obj, 'model');
+        const roleValue = getPropertyValue(obj, 'role');
+        const personalityValue = getPropertyValue(obj, 'personality');
+        const goalValue = getPropertyValue(obj, 'goal');
+        const maxStepsValue = getPropertyValue(obj, 'maxSteps');
+        const temperatureValue = getPropertyValue(obj, 'temperature');
+        const toolChoiceValue = getPropertyValue(obj, 'toolChoice');
+        const scorersValue = resolveScorerNames(obj, nameValue || '', logger);
+        const toolsValue = resolveToolReferences(obj, checker, nameValue || '', logger);
+        if (toolsValue) {
+            for (const toolName of toolsValue) {
+                if (toolName.startsWith('workflow:') || toolName.includes(':'))
+                    continue;
+                const funcFile = state.functions.files.get(toolName);
+                if (funcFile && !state.rpc.internalFiles.has(toolName)) {
+                    state.rpc.internalFiles.set(toolName, funcFile);
+                }
+            }
+        }
+        const agentsValue = resolveAgentReferences(obj, checker, nameValue || '', logger);
+        const workflowsValue = resolveWorkflowReferences(obj, checker, nameValue || '', logger);
+        if (workflowsValue) {
+            for (const workflowName of workflowsValue) {
+                state.workflows.invokedWorkflows.add(workflowName);
+            }
+        }
+        if (!nameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, "AI agent is missing the required 'name' property.");
+            return;
+        }
+        const agentKey = exportedName || nameValue;
+        if (!description) {
+            logger.critical(ErrorCode.MISSING_DESCRIPTION, `AI agent '${nameValue}' is missing a description.`);
+            return;
+        }
+        const resolveSchemaRef = (identifier, context) => {
+            const symbol = checker.getSymbolAtLocation(identifier);
+            if (!symbol)
+                return null;
+            const decl = symbol.valueDeclaration || symbol.declarations?.[0];
+            if (!decl)
+                return null;
+            let sourceFile;
+            if (ts.isImportSpecifier(decl)) {
+                const aliasedSymbol = checker.getAliasedSymbol(symbol);
+                if (aliasedSymbol) {
+                    const aliasedDecl = aliasedSymbol.valueDeclaration || aliasedSymbol.declarations?.[0];
+                    if (aliasedDecl) {
+                        sourceFile = aliasedDecl.getSourceFile().fileName;
+                    }
+                    else {
+                        return null;
+                    }
+                }
+                else {
+                    return null;
+                }
+            }
+            else {
+                sourceFile = decl.getSourceFile().fileName;
+            }
+            const vendor = detectSchemaVendorOrError(identifier, checker, logger, context, sourceFile);
+            if (!vendor)
+                return null;
+            return {
+                variableName: identifier.text,
+                sourceFile,
+                vendor,
+            };
+        };
+        let inputSchema = null;
+        let outputSchema = null;
+        let workingMemorySchema = null;
+        const capitalizedName = funcIdToTypeName(agentKey);
+        for (const prop of obj.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                const propName = prop.name.text;
+                if (propName === 'input' || propName === 'output') {
+                    if (ts.isIdentifier(prop.initializer)) {
+                        const context = `AI agent '${nameValue}' ${propName}`;
+                        const ref = resolveSchemaRef(prop.initializer, context);
+                        if (ref) {
+                            const schemaName = `${capitalizedName}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
+                            state.schemaLookup.set(schemaName, ref);
+                            state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
+                            if (propName === 'input') {
+                                inputSchema = schemaName;
+                            }
+                            else {
+                                outputSchema = schemaName;
+                            }
+                        }
+                    }
+                    else if (ts.isCallExpression(prop.initializer)) {
+                        const schemaName = `${capitalizedName}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
+                        logger.critical(ErrorCode.INLINE_SCHEMA, `Inline schemas are not supported for '${propName}' in AI agent '${nameValue}'.\n` +
+                            `  Extract to an exported variable:\n` +
+                            `    export const ${schemaName} = ${prop.initializer.getText()}\n` +
+                            `  Then use: ${propName}: ${schemaName}`);
+                    }
+                }
+                else if (propName === 'memory' &&
+                    ts.isObjectLiteralExpression(prop.initializer)) {
+                    for (const memProp of prop.initializer.properties) {
+                        if (ts.isPropertyAssignment(memProp) &&
+                            ts.isIdentifier(memProp.name) &&
+                            memProp.name.text === 'workingMemory' &&
+                            ts.isIdentifier(memProp.initializer)) {
+                            const context = `AI agent '${nameValue}' workingMemory`;
+                            const ref = resolveSchemaRef(memProp.initializer, context);
+                            if (ref) {
+                                const schemaName = `${capitalizedName}WorkingMemory`;
+                                state.schemaLookup.set(schemaName, ref);
+                                state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
+                                workingMemorySchema = schemaName;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const middleware = resolveMiddleware(state, obj, tags, checker);
+        const channelMiddleware = resolveChannelMiddleware(state, obj, tags, checker);
+        const agentMiddleware = resolveAgentMiddleware(state, obj, checker);
+        const permissions = resolvePermissions(state, obj, tags, checker);
+        state.serviceAggregation.usedFunctions.add(agentKey);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+        extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
+        if (exportedName) {
+            state.agents.files.set(agentKey, {
+                path: node.getSourceFile().fileName,
+                exportedName,
+            });
+        }
+        state.agents.agentsMeta[agentKey] = {
+            name: nameValue,
+            description,
+            role: roleValue || undefined,
+            personality: personalityValue || undefined,
+            goal: goalValue || '',
+            model: modelValue || '',
+            summary,
+            errors,
+            sourceFile: node.getSourceFile().fileName,
+            exportedName: exportedName || undefined,
+            ...(maxStepsValue !== null && { maxSteps: maxStepsValue }),
+            ...(temperatureValue !== null && { temperature: temperatureValue }),
+            ...(toolChoiceValue !== null && {
+                toolChoice: toolChoiceValue,
+            }),
+            ...(toolsValue !== null && { tools: toolsValue }),
+            ...(agentsValue !== null && { agents: agentsValue }),
+            ...(workflowsValue !== null && { workflows: workflowsValue }),
+            ...(scorersValue !== null && { scorers: scorersValue }),
+            tags,
+            inputSchema,
+            outputSchema,
+            workingMemorySchema,
+            middleware,
+            channelMiddleware,
+            agentMiddleware,
+            permissions,
+        };
+        // AI agent functions require platform services that aren't visible
+        // through parameter destructuring
+        const funcMeta = state.functions.meta[agentKey];
+        if (funcMeta?.services) {
+            for (const svc of [
+                'agentStorage',
+                'agentRunState',
+                'agentRunService',
+                'agentRunner',
+            ]) {
+                if (!funcMeta.services.services.includes(svc)) {
+                    funcMeta.services.services.push(svc);
+                }
+            }
+        }
+    }
+};

package/dist/add/add-channel.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
-import type { ChannelMeta } from '@pikku/core/channel';
+import type { ChannelMeta } from '@pikku/core/ecosystem/channel';
 import type { InspectorState, AddWiring } from '../types.js';
 /**
  * Build out the nested message-routes by looking up each handler

package/dist/add/add-functions.js

@@ -3,7 +3,7 @@ import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
 import { extractFunctionName, funcIdToTypeName, } from '../utils/extract-function-name.js';
 import { extractFunctionNode } from '../utils/extract-function-node.js';
 import { extractUsedWires } from '../utils/extract-services.js';
-import { formatVersionedId, parseVersionedId } from '@pikku/core';
+import { formatVersionedId, parseVersionedId, } from '@pikku/core/ecosystem/types';
 /** Binding keys a `pikkuScenarioStep` may declare, in report order. */
 const SCENARIO_SURFACE_KEYS = [
     'browser',

package/dist/add/add-keyed-wiring.js

@@ -2,7 +2,7 @@ import * as ts from 'typescript';
 import { getPropertyValue, getArrayPropertyValue, assertStringLiteralProperty, } from '../utils/get-property-value.js';
 import { ErrorCode } from '../error-codes.js';
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
-import { parseDurationString } from '@pikku/core';
+import { parseDurationString } from '@pikku/core/ecosystem/types';
 export const createAddKeyedWiring = (config) => {
     return (logger, node, checker, state, _options) => {
         if (!ts.isCallExpression(node)) {

package/dist/add/add-middleware.js

@@ -508,12 +508,12 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found channel middleware factory with services: ${services.services.join(', ')}`);
         return;
     }
-    if (expression.text === 'pikkuAIMiddleware') {
+    if (expression.text === 'pikkuAgentMiddleware') {
         const arg = args[0];
         if (!arg)
             return;
         if (!ts.isObjectLiteralExpression(arg)) {
-            logger.error(`• pikkuAIMiddleware() requires an object literal argument.`);
+            logger.error(`• pikkuAgentMiddleware() requires an object literal argument.`);
             return;
         }
         const allServices = new Set();
@@ -542,12 +542,12 @@ export const addMiddleware = (logger, node, checker, state) => {
                 pikkuFuncId = node.parent.name.text;
             }
             else {
-                logger.error(`• pikkuAIMiddleware() must be assigned to a variable or object property. ` +
-                    `Extract it to a const: const myMiddleware = pikkuAIMiddleware(...)`);
+                logger.error(`• pikkuAgentMiddleware() must be assigned to a variable or object property. ` +
+                    `Extract it to a const: const myMiddleware = pikkuAgentMiddleware(...)`);
                 return;
             }
         }
-        state.aiMiddleware.definitions[pikkuFuncId] = {
+        state.agentMiddleware.definitions[pikkuFuncId] = {
             services,
             sourceFile: node.getSourceFile().fileName,
             position: node.getStart(),

package/dist/add/add-personas.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { DISPOSITIONS } from '@pikku/core/virtual-user';
+import { DISPOSITIONS } from '@pikku/core/ecosystem/virtual-user';
 import { isRunnablePersona } from '@pikku/core/persona';
 import { ErrorCode } from '../error-codes.js';
 import { claimSingleDeclaration } from '../utils/single-declaration.js';

package/dist/add/add-workflow.d.ts

@@ -1,5 +1,5 @@
 import type { AddWiring } from '../types.js';
-import type { WorkflowStepMeta } from '@pikku/core/workflow';
+import type { WorkflowStepMeta } from '@pikku/core/ecosystem/workflow';
 /**
  * Recursively collect all RPC names from workflow steps
  */

package/dist/inspector.js

@@ -177,7 +177,7 @@ export function getInitialInspectorState(rootDir) {
             instances: {},
             tagMiddleware: new Map(),
         },
-        aiMiddleware: {
+        agentMiddleware: {
             definitions: {},
         },
         permissions: {