@pikku/inspector 0.12.60 → 0.12.61

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

@@ -1,4 +0,0 @@
-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 addAIAgent: AddWiring;

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

@@ -1,442 +0,0 @@
-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, resolveAIMiddleware, } 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 pikkuAIAgent 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 pikkuAIAgent.`);
-        }
-    }
-    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 === 'pikkuAIAgent') {
-            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 addAIAgent = (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 !== 'pikkuAIAgent') {
-        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 aiMiddleware = resolveAIMiddleware(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,
-            aiMiddleware,
-            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 [
-                'aiStorage',
-                'aiRunState',
-                'agentRunService',
-                'aiAgentRunner',
-            ]) {
-                if (!funcMeta.services.services.includes(svc)) {
-                    funcMeta.services.services.push(svc);
-                }
-            }
-        }
-    }
-};

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

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

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

@@ -1,61 +0,0 @@
-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';
-/**
- * `pikkuAIScorer` grades in code and `pikkuAIJudge` 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 = {
-    pikkuAIScorer: 'fast',
-    pikkuAIJudge: 'slow',
-};
-export const addAIScorer = (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/utils/secret-brokers.d.ts

@@ -1,2 +0,0 @@
-/** Whether this function keeps the full `SecretService`. */
-export declare const isSecretBrokerFunction: (functionId: string) => boolean;

package/dist/utils/secret-brokers.js

@@ -1,9 +0,0 @@
-/** The console's secret administration functions, and nothing else. */
-const SECRET_BROKER_FUNCTIONS = new Set([
-    'pikkuConsoleSetSecret',
-    'pikkuConsoleGetSecret',
-    'pikkuConsoleHasSecret',
-]);
-/** Whether this function keeps the full `SecretService`. */
-export const isSecretBrokerFunction = (functionId) => SECRET_BROKER_FUNCTIONS.has(functionId) ||
-    SECRET_BROKER_FUNCTIONS.has(functionId.split(':').pop() ?? '');