@pikku/core 0.12.79 → 0.12.82

package/dist/function/function-runner.js

@@ -84,7 +84,6 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
         throw new Error(`Function meta not found: ${funcName}`);
     }
     const resolvedFunctionId = funcMeta.pikkuFuncId ?? funcName;
-    const keepsSecrets = funcMeta.secretBroker === true;
     const resolvedSingletonServices = packageName
         ? await getOrCreatePackageSingletonServices(packageName, singletonServices, addonInstance)
         : singletonServices;
@@ -124,6 +123,23 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
     const previousAudit = invocationWire.audit;
     const previousAddonNamespace = invocationWire.addonNamespace;
     const previousRpcDescriptor = Object.getOwnPropertyDescriptor(invocationWire, 'rpc');
+    // knowledge: decisions/internals/core-function-runner-restores-the-wire-fields-it-overwrites.md
+    const restoreInvocationWire = () => {
+        if (previousRpcDescriptor) {
+            Object.defineProperty(invocationWire, 'rpc', previousRpcDescriptor);
+        }
+        restoreField('functionId', previousFunctionId);
+        restoreField('audit', previousAudit);
+        restoreField('addonNamespace', previousAddonNamespace);
+    };
+    function restoreField(key, previous) {
+        if (previous === undefined) {
+            delete invocationWire[key];
+        }
+        else {
+            invocationWire[key] = previous;
+        }
+    }
     invocationWire.functionId = resolvedFunctionId;
     invocationWire.audit = resolvedAuditConfig;
     // Track which addon instance is executing so intra-addon sibling calls
@@ -184,9 +200,8 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
         }
         await runPermissions({
             funcPermissions: funcConfig.permissions,
-            services: keepsSecrets
-                ? resolvedSingletonServices
-                : withoutSecrets(resolvedSingletonServices, 'a permission'),
+            services: withoutSecrets(resolvedSingletonServices, 'a permission'),
+            // knowledge: decisions/security/a-permission-gets-a-wire-it-cannot-reply-on.md
             wire: invocationWire,
             data: actualData,
             packageName,
@@ -219,7 +234,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
                 configurable: true,
                 enumerable: true,
             });
-            return await funcConfig.func(keepsSecrets ? services : withoutSecrets(services, 'a pikku function'), actualData, invocationWire);
+            return await funcConfig.func(withoutSecrets(services, 'a pikku function'), actualData, invocationWire);
         }
         finally {
             // Flush the runner-installed audit buffer before wire services close.
@@ -244,53 +259,13 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
             return (await runMiddleware(resolvedSingletonServices, invocationWire, allMiddleware, executeFunction));
         }
         finally {
-            if (previousRpcDescriptor) {
-                Object.defineProperty(invocationWire, 'rpc', previousRpcDescriptor);
-            }
-            if (previousFunctionId === undefined) {
-                delete invocationWire.functionId;
-            }
-            else {
-                invocationWire.functionId = previousFunctionId;
-            }
-            if (previousAudit === undefined) {
-                delete invocationWire.audit;
-            }
-            else {
-                invocationWire.audit = previousAudit;
-            }
-            if (previousAddonNamespace === undefined) {
-                delete invocationWire.addonNamespace;
-            }
-            else {
-                invocationWire.addonNamespace = previousAddonNamespace;
-            }
+            restoreInvocationWire();
         }
     }
     try {
         return (await executeFunction());
     }
     finally {
-        if (previousRpcDescriptor) {
-            Object.defineProperty(invocationWire, 'rpc', previousRpcDescriptor);
-        }
-        if (previousFunctionId === undefined) {
-            delete invocationWire.functionId;
-        }
-        else {
-            invocationWire.functionId = previousFunctionId;
-        }
-        if (previousAudit === undefined) {
-            delete invocationWire.audit;
-        }
-        else {
-            invocationWire.audit = previousAudit;
-        }
-        if (previousAddonNamespace === undefined) {
-            delete invocationWire.addonNamespace;
-        }
-        else {
-            invocationWire.addonNamespace = previousAddonNamespace;
-        }
+        restoreInvocationWire();
     }
 };

package/dist/function/functions.types.d.ts

@@ -5,11 +5,6 @@ import type { PikkuError } from '../errors/error-handler.js';
 import type { CoreNodeConfig } from '../wirings/node/node.types.js';
 import type { ScenarioSurface } from '../wirings/workflow/scenario-step.types.js';
 import type { Safe } from '../secret-value.js';
-/**
- * @deprecated Use StandardSchemaV1 from @standard-schema/spec instead.
- * This alias exists only for backward compatibility with generated code.
- */
-export type ZodLike<T = any> = StandardSchemaV1<T, T>;
 export type CorePikkuFunction<In, Out, Services extends CoreSecretlessSingletonServices = SecretlessServices<CoreServices>, Session extends CoreUserSession = CoreUserSession, Wire extends PikkuWire<In, Out, true, Session, PikkuRPC, null, string> = PikkuWire<In, Out, true, Session>> = (services: Services, data: In, wire: Wire) => Wire['channel'] extends null ? Promise<Safe<Out>> : Promise<Safe<Out>> | Promise<void>;
 export type CorePikkuFunctionSessionless<In, Out, Services extends CoreSecretlessSingletonServices = SecretlessServices<CoreServices>, Session extends CoreUserSession = CoreUserSession, Wire extends PikkuWire<In, Out, false, Session, PikkuRPC, null, string> = PikkuWire<In, Out, false, Session>> = (services: Services, data: In, wire: Wire) => Wire['channel'] extends null ? Promise<Safe<Out>> : Promise<Safe<Out>> | Promise<void>;
 export type CorePikkuPermission<In = any, Services extends CoreSecretlessSingletonServices = SecretlessServices<CoreServices>, Wire extends PikkuWire<In, never, false, any, PikkuRPC, never, never> = PikkuWire<In, never, false, any, PikkuRPC, never, never>> = (services: Services, data: In, wire: Wire) => Promise<boolean>;
@@ -33,6 +28,15 @@ export type CorePikkuAuthConfig<Services extends CoreSecretlessSingletonServices
     name?: string;
     description?: string;
 };
+/**
+ * Marks a permission produced by `pikkuAuth`, so agent tool filtering can tell a
+ * session check apart from an ordinary permission.
+ *
+ * knowledge: decisions/security/permission-auth-filtering-requires-live-permission-functions.md
+ */
+export type AuthBranded = {
+    __pikkuAuth?: true;
+};
 export declare const pikkuAuth: <Services extends CoreSecretlessSingletonServices = SecretlessServices<CoreServices>, Session extends CoreUserSession = CoreUserSession>(auth: CorePikkuAuth<Services, Session> | CorePikkuAuthConfig<Services, Session>) => CorePikkuPermission<any, Services, any>;
 export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
 /**

package/dist/function/index.d.ts

@@ -1,4 +1,4 @@
 export { addFunction, getAllFunctionNames } from './function-runner.js';
 export { pikkuAuth, pikkuPermission, pikkuPermissionFactory, pikkuApprovalDescription, } from './functions.types.js';
 export type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuFunctionConfig, CorePikkuSessionlessFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, } from './functions.types.js';
-export type { ListInput, ListOutput, Filter, LeafFilter, LeafValue, } from './list.types.js';
+export type { ListInput, ListOutput, Filter, } from './list.types.js';

package/dist/index.d.ts

@@ -1,30 +1,26 @@
 /**
  * @module @pikku/core
  */
-export type { AuthInstance, CommonWireMeta, CoreConfig, CorePikkuMiddleware, CorePikkuMiddlewareConfig, CorePikkuMiddlewareFactory, CorePikkuMiddlewareGroup, CoreServices, CoreSecretlessSingletonServices, CoreSingletonServices, CoreUserSession, SecretlessServices, CreateConfig, ServerLifecycle, FunctionMeta, FunctionRuntimeMeta, FunctionServicesMeta, FunctionWiresMeta, FunctionsMeta, FunctionsRuntimeMeta, JSONPrimitive, JSONValue, MakeRequired, MiddlewareMetadata, MiddlewarePriority, PermissionMetadata, PickOptional, PickRequired, PikkuAIMiddlewareHooks, PikkuWire, PikkuRawWire, PikkuWiringTypes, PostgresConfig, RequireAtLeastOne, SecurityAuditIssue, SecurityAuditReport, SecurityAuditSummary, SecurityAuditUpdate, SecuritySeverity, SecurityUpdateLevel, SerializedError, WireServices, } from './types/core.types.js';
+export type { AuthInstance, CommonWireMeta, CoreConfig, CorePikkuMiddleware, CorePikkuMiddlewareConfig, CorePikkuMiddlewareFactory, CorePikkuMiddlewareGroup, CoreServices, CoreSecretlessSingletonServices, CoreSingletonServices, CoreUserSession, SecretlessServices, CreateConfig, ServerLifecycle, FunctionMeta, FunctionServicesMeta, FunctionWiresMeta, FunctionsMeta, FunctionsRuntimeMeta, JSONValue, MakeRequired, MiddlewareMetadata, MiddlewarePriority, PermissionMetadata, PickOptional, PickRequired, PikkuAIMiddlewareHooks, PikkuWire, PikkuRawWire, PikkuWiringTypes, PostgresConfig, RequireAtLeastOne, SecurityAuditIssue, SecurityAuditReport, SecurityAuditSummary, SecurityAuditUpdate, SecuritySeverity, SecurityUpdateLevel, SerializedError, } from './types/core.types.js';
 export { pikkuAIMiddleware, pikkuChannelMiddleware, pikkuChannelMiddlewareFactory, pikkuMiddleware, pikkuMiddlewareFactory, } from './types/core.types.js';
-export type { CorePikkuAuth, CorePikkuAuthConfig, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionHook, CorePikkuPermission, CorePikkuPermissionConfig, CorePikkuPermissionFactory, CorePikkuApprovalDescription, CorePermissionGroup, ZodLike, } from './function/functions.types.js';
+export type { CorePikkuAuth, CorePikkuAuthConfig, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuPermissionConfig, CorePikkuPermissionFactory, CorePikkuApprovalDescription, CorePermissionGroup, } from './function/functions.types.js';
 export { pikkuAuth, pikkuPermission, pikkuPermissionFactory, pikkuApprovalDescription, } from './function/functions.types.js';
-export { addFunction, getAllFunctionNames } from './function/index.js';
-export type { ListInput, ListOutput, Filter, LeafFilter, LeafValue, } from './function/list.types.js';
+export { getAllFunctionNames } from './function/index.js';
+export type { ListInput, ListOutput, Filter, } from './function/list.types.js';
+export { pikkuCLIRender } from './wirings/cli/cli-runner.js';
 export { PikkuRequest } from './pikku-request.js';
 export { getRelativeTimeOffsetFromNow, parseDurationString, } from './time-utils.js';
 export type { RelativeTimeInput } from './time-utils.js';
 export { formatVersionedId, isVersionedId, parseVersionedId, } from './version.js';
-export { runPikkuFunc } from './function/function-runner.js';
-export { AbandonedError, beginChanges, getAbortScope, runInAbortScope, type AbortScope, } from './function/abort-scope.js';
-export { runCLICommand, pikkuCLIRender } from './wirings/cli/cli-runner.js';
+export { AbandonedError, type AbortScope, } from './function/abort-scope.js';
 export { fetch } from './wirings/http/http-runner.js';
-export { runMCPTool, runMCPResource, runMCPPrompt, } from './wirings/mcp/mcp-runner.js';
 export type { MCPToolResponse, MCPResourceResponse, MCPPromptResponse, } from './wirings/mcp/mcp.types.js';
-export { runQueueJob } from './wirings/queue/queue-runner.js';
-export { runScheduledTask } from './wirings/scheduler/scheduler-runner.js';
 export { AIProviderAuthError, AIProviderNotConfiguredError, BadGatewayError, BadRequestError, ConflictError, ExpectationFailedError, ForbiddenError, GatewayTimeoutError, GoneError, HTTPVersionNotSupportedError, InternalServerError, InvalidMiddlewareWireError, InvalidOriginError, InvalidSessionError, LengthRequiredError, LocalEnvironmentOnlyError, LockedError, MaxComputeTimeReachedError, MethodNotAllowedError, MissingCredentialError, MissingSchemaError, MissingScopeError, MissingServiceError, MissingSessionError, NotAcceptableError, NotFoundError, NotImplementedError, PayloadTooLargeError, PaymentRequiredError, PikkuMissingMetaError, PreconditionFailedError, ProxyAuthenticationRequiredError, RangeNotSatisfiableError, ReadonlySessionError, RequestTimeoutError, ServiceUnavailableError, TooManyRequestsError, URITooLongError, UnauthorizedError, UnprocessableContentError, UnsupportedMediaTypeError, } from './errors/errors.js';
 export { PikkuError, isExpectedError } from './errors/error-handler.js';
 export type { EventHubService } from './wirings/channel/eventhub-service.js';
 export type { QueueService } from './wirings/queue/queue.types.js';
 export type { JWTService } from './services/jwt-service.js';
-export type { EmailService, EmailTemplateReference, SendEmailInput, SendEmailResult, SendHTMLEmailInput, SendTemplateEmailInput, SendTextEmailInput, } from './services/email-service.js';
+export type { EmailService, SendEmailInput, SendEmailResult, SendHTMLEmailInput, SendTemplateEmailInput, SendTextEmailInput, } from './services/email-service.js';
 export type { SecretService } from './services/secret-service.js';
 export { SecretAccessDeniedError, withoutSecrets, } from './services/secretless.js';
 export { SecretHostNotAllowedError, assertSecretAllowedForHost, } from './services/secret-host-binding.js';
@@ -36,13 +32,13 @@ export type { GatewayService } from './services/gateway-service.js';
 export type { TriggerService } from './services/trigger-service.js';
 export type { SchemaService } from './services/schema-service.js';
 export type { SessionService } from './services/user-session-service.js';
-export { NoopAuditService, createInvocationAudit, resolveAuditConfig, resolveAuditUserIdentityFromWire, } from './services/audit-service.js';
-export type { AuditConfig, AuditDurability, AuditEvent, AuditEventBatch, AuditFacets, AuditLog, AuditLogWriteInput, AuditOutcome, AuditQuery, AuditQueryResult, AuditService, AuditSource, AuditUserIdentity, ResolvedAuditConfig, } from './services/audit-service.js';
-export type { AIAgentRunnerService, AIEmbedManyParams, AIEmbedManyResult, AIEmbedParams, AIEmbedResult, AIGenerateImageParams, AIGenerateImagePrompt, AIGenerateImageResult, AIGenerateSpeechParams, AIGenerateSpeechResult, AIProviderOptions, AIRerankParams, AIRerankResult, AITranscriptionParams, AITranscriptionResult, } from './services/ai-agent-runner-service.js';
+export { NoopAuditService, createInvocationAudit, } from './services/audit-service.js';
+export type { AuditConfig, AuditDurability, AuditEvent, AuditEventBatch, AuditFacets, AuditLog, AuditQuery, AuditQueryResult, AuditService, AuditUserIdentity, ResolvedAuditConfig, } from './services/audit-service.js';
+export type { AIAgentRunnerService, } from './services/ai-agent-runner-service.js';
 export type { AIEmbeddingService } from './services/ai-embedding-service.js';
 export type { AIRunStateService } from './services/ai-run-state-service.js';
 export type { AIStorageService } from './services/ai-storage-service.js';
-export type { EmailsMeta, EmailTemplateMeta, EmailTemplateLocaleMeta, EmailTemplateAssets, MetaService, } from './services/meta-service.js';
+export type { EmailsMeta, EmailTemplateMeta, MetaService, } from './services/meta-service.js';
 export type { HTTPMethod } from './wirings/http/http.types.js';
 export type { GraphNodeConfig } from './wirings/workflow/graph/workflow-graph.types.js';
 export { createGraph } from './wirings/workflow/graph/graph-node.js';
@@ -51,15 +47,14 @@ export type { WireAddonConfig } from './wirings/rpc/wire-addon.js';
 export { wireRemoteAddon } from './wirings/rpc/wire-remote-addon.js';
 export type { WireRemoteAddonConfig, RemoteAddonAuth, } from './wirings/rpc/wire-remote-addon.js';
 export type { PikkuPackageState } from './types/state.types.js';
-export { runMiddleware, addTagMiddleware, addTagMiddleware as addMiddleware, addGlobalMiddleware, } from './middleware-runner.js';
+export { runMiddleware, addTagMiddleware } from './middleware-runner.js';
 export { addGlobalPermission, checkAuthPermissions } from './permissions.js';
 export { hasScopes, verifyScopes } from './scopes.js';
 export { isSerializable, stopSingletonServices, pikkuServerLifecycle, } from './utils.js';
-export { getSingletonServices, getCreateWireServices, setSingletonServices, } from './pikku-state.js';
 export { clearPikkuRuntimeState } from './test-utils.js';
 export { type ScheduledTaskInfo, type ScheduledTaskSummary, } from './services/scheduler-service.js';
 export { SchedulerService } from './services/scheduler-service.js';
-export type { Private, Pii, Secret, Classification, AnonymizeStrategy, ColumnClassification, ClassificationManifest, ColumnForm, WrappedValue, SealedValue, HashedValue, } from './data-classification.js';
-export { hashToken, unsafeAsWrapped, unsafeAsSealed, unsafeAsHashed, } from './column-form.js';
+export type { Private, Pii, Secret, Classification, AnonymizeStrategy, ClassificationManifest, ColumnForm, WrappedValue, SealedValue, HashedValue, } from './data-classification.js';
+export { hashToken, } from './column-form.js';
 export type { SecretValue, Safe } from './secret-value.js';
 export { createSecretValue, isSecretValue, SecretCoercionError, REDACTED, } from './secret-value.js';

package/dist/index.js

@@ -1,30 +1,25 @@
 export { pikkuAIMiddleware, pikkuChannelMiddleware, pikkuChannelMiddlewareFactory, pikkuMiddleware, pikkuMiddlewareFactory, } from './types/core.types.js';
 export { pikkuAuth, pikkuPermission, pikkuPermissionFactory, pikkuApprovalDescription, } from './function/functions.types.js';
-export { addFunction, getAllFunctionNames } from './function/index.js';
+export { getAllFunctionNames } from './function/index.js';
+export { pikkuCLIRender } from './wirings/cli/cli-runner.js';
 export { PikkuRequest } from './pikku-request.js';
 export { getRelativeTimeOffsetFromNow, parseDurationString, } from './time-utils.js';
 export { formatVersionedId, isVersionedId, parseVersionedId, } from './version.js';
-export { runPikkuFunc } from './function/function-runner.js';
-export { AbandonedError, beginChanges, getAbortScope, runInAbortScope, } from './function/abort-scope.js';
-export { runCLICommand, pikkuCLIRender } from './wirings/cli/cli-runner.js';
+export { AbandonedError, } from './function/abort-scope.js';
 export { fetch } from './wirings/http/http-runner.js';
-export { runMCPTool, runMCPResource, runMCPPrompt, } from './wirings/mcp/mcp-runner.js';
-export { runQueueJob } from './wirings/queue/queue-runner.js';
-export { runScheduledTask } from './wirings/scheduler/scheduler-runner.js';
 export { AIProviderAuthError, AIProviderNotConfiguredError, BadGatewayError, BadRequestError, ConflictError, ExpectationFailedError, ForbiddenError, GatewayTimeoutError, GoneError, HTTPVersionNotSupportedError, InternalServerError, InvalidMiddlewareWireError, InvalidOriginError, InvalidSessionError, LengthRequiredError, LocalEnvironmentOnlyError, LockedError, MaxComputeTimeReachedError, MethodNotAllowedError, MissingCredentialError, MissingSchemaError, MissingScopeError, MissingServiceError, MissingSessionError, NotAcceptableError, NotFoundError, NotImplementedError, PayloadTooLargeError, PaymentRequiredError, PikkuMissingMetaError, PreconditionFailedError, ProxyAuthenticationRequiredError, RangeNotSatisfiableError, ReadonlySessionError, RequestTimeoutError, ServiceUnavailableError, TooManyRequestsError, URITooLongError, UnauthorizedError, UnprocessableContentError, UnsupportedMediaTypeError, } from './errors/errors.js';
 export { PikkuError, isExpectedError } from './errors/error-handler.js';
 export { SecretAccessDeniedError, withoutSecrets, } from './services/secretless.js';
 export { SecretHostNotAllowedError, assertSecretAllowedForHost, } from './services/secret-host-binding.js';
-export { NoopAuditService, createInvocationAudit, resolveAuditConfig, resolveAuditUserIdentityFromWire, } from './services/audit-service.js';
+export { NoopAuditService, createInvocationAudit, } from './services/audit-service.js';
 export { createGraph } from './wirings/workflow/graph/graph-node.js';
 export { wireAddon } from './wirings/rpc/wire-addon.js';
 export { wireRemoteAddon } from './wirings/rpc/wire-remote-addon.js';
-export { runMiddleware, addTagMiddleware, addTagMiddleware as addMiddleware, addGlobalMiddleware, } from './middleware-runner.js';
+export { runMiddleware, addTagMiddleware } from './middleware-runner.js';
 export { addGlobalPermission, checkAuthPermissions } from './permissions.js';
 export { hasScopes, verifyScopes } from './scopes.js';
 export { isSerializable, stopSingletonServices, pikkuServerLifecycle, } from './utils.js';
-export { getSingletonServices, getCreateWireServices, setSingletonServices, } from './pikku-state.js';
 export { clearPikkuRuntimeState } from './test-utils.js';
 export { SchedulerService } from './services/scheduler-service.js';
-export { hashToken, unsafeAsWrapped, unsafeAsSealed, unsafeAsHashed, } from './column-form.js';
+export { hashToken, } from './column-form.js';
 export { createSecretValue, isSecretValue, SecretCoercionError, REDACTED, } from './secret-value.js';

package/dist/middleware/auth-cookie.d.ts

@@ -1,9 +1,5 @@
 import type { SerializeOptions } from 'cookie';
 import type { RelativeTimeInput } from '../time-utils.js';
-/**
- * Reads a JWT session from a cookie, and re-issues the cookie after the
- * request whenever the session changed (e.g. after login).
- */
 export declare const authCookie: import("../types/core.types.js").CorePikkuMiddlewareFactory<{
     name: string;
     options: SerializeOptions;

package/dist/middleware/auth-cookie.js

@@ -4,6 +4,26 @@ import { getRelativeTimeOffsetFromNow } from '../time-utils.js';
  * Reads a JWT session from a cookie, and re-issues the cookie after the
  * request whenever the session changed (e.g. after login).
  */
+/** Standard JWT registered claims — present on a token even with no session. */
+const JWT_REGISTERED_CLAIMS = new Set([
+    'iat',
+    'exp',
+    'nbf',
+    'iss',
+    'aud',
+    'sub',
+    'jti',
+]);
+/**
+ * Whether a decoded payload carries an actual session, as opposed to being
+ * absent or a bare JWT envelope of `{ iat, exp }`. True only for a non-null
+ * object with at least one key that is not a registered JWT claim.
+ */
+const hasSessionIdentity = (session) => {
+    if (!session || typeof session !== 'object')
+        return false;
+    return Object.keys(session).some((key) => !JWT_REGISTERED_CLAIMS.has(key));
+};
 export const authCookie = pikkuMiddlewareFactory(({ name, options, expiresIn }) => {
     const mergedOptions = {
         httpOnly: true,
@@ -19,7 +39,12 @@ export const authCookie = pikkuMiddlewareFactory(({ name, options, expiresIn })
         const cookieValue = http.request.cookie(name);
         if (cookieValue && jwtService) {
             const userSession = await jwtService.decode(cookieValue);
-            if (userSession) {
+            // Not just truthy: a JWT of an absent session still decodes to a
+            // `{ iat, exp }` object, which is truthy and which the function runner
+            // would accept as a session. Require at least one claim that is not a
+            // standard JWT timestamp, so an identity-less token is treated as no
+            // session rather than as an authenticated one.
+            if (userSession && hasSessionIdentity(userSession)) {
                 setSession?.(userSession);
             }
         }
@@ -29,7 +54,18 @@ export const authCookie = pikkuMiddlewareFactory(({ name, options, expiresIn })
         }
         if (hasSessionChanged?.()) {
             const currentSession = await getSession?.();
-            if (jwtService) {
+            // Logout path: `clearSession()` marks the session changed while leaving
+            // it absent. Re-signing that into a fresh, unexpired cookie would hand
+            // the browser a credential on the way out — so clear the cookie instead
+            // of minting one, and never call `encode` with an absent session.
+            if (!hasSessionIdentity(currentSession)) {
+                http.response.cookie(name, '', {
+                    ...mergedOptions,
+                    expires: new Date(0),
+                    maxAge: 0,
+                });
+            }
+            else if (jwtService) {
                 http.response.cookie(name, await jwtService.encode(expiresIn, currentSession), {
                     ...mergedOptions,
                     expires: getRelativeTimeOffsetFromNow(expiresIn),

package/dist/middleware/cors.js

@@ -45,6 +45,7 @@ export const cors = pikkuMiddlewareFactory(({ origin = '*', methods = ['GET', 'P
             }
             if (request.method() === 'options') {
                 response.header('Access-Control-Max-Age', String(maxAge));
+                // 204 carries no body, and `json` has no no-content overload.
                 response.status(204).json(undefined);
                 return;
             }

package/dist/middleware/index.d.ts

@@ -5,4 +5,4 @@ export { pikkuRemoteAuthMiddleware } from './remote-auth.js';
 export { cors } from './cors.js';
 export { telemetryOuter, telemetryInner } from './telemetry.js';
 export { addTagMiddleware, addTagMiddleware as addMiddleware, addGlobalMiddleware, runMiddleware, } from '../middleware-runner.js';
-export { addGlobalPermission, addTagPermission } from '../permissions.js';
+export { addGlobalPermission } from '../permissions.js';

package/dist/middleware/index.js

@@ -5,4 +5,4 @@ export { pikkuRemoteAuthMiddleware } from './remote-auth.js';
 export { cors } from './cors.js';
 export { telemetryOuter, telemetryInner } from './telemetry.js';
 export { addTagMiddleware, addTagMiddleware as addMiddleware, addGlobalMiddleware, runMiddleware, } from '../middleware-runner.js';
-export { addGlobalPermission, addTagPermission } from '../permissions.js';
+export { addGlobalPermission } from '../permissions.js';

package/dist/middleware/remote-auth.js

@@ -1,6 +1,15 @@
 import { UnauthorizedError } from '../errors/errors.js';
 import { pikkuMiddleware } from '../types/core.types.js';
 import { assertStrongKeyMaterial, decryptWithKeyMaterial, REMOTE_SESSION_INFO, } from '../crypto-utils.js';
+const REMOTE_RPC_PREFIX = '/remote/rpc/';
+/**
+ * Whether this request targets the remote-RPC surface. Compared case-insensitively
+ * because the router matches routes that way (path-to-regexp defaults to
+ * `sensitive: false`), so `/Remote/RPC/fn` reaches the same handler as
+ * `/remote/rpc/fn`. A case-sensitive check here let a case-varied path slip
+ * past the trust gate and the token's `fn` binding while still being dispatched.
+ */
+const isRemoteRpcPath = (path) => path.toLowerCase().startsWith(REMOTE_RPC_PREFIX);
 export const pikkuRemoteAuthMiddleware = pikkuMiddleware(async ({ secrets, jwt }, { http, setSession }, next) => {
     if (!http?.request || !secrets) {
         return next();
@@ -10,7 +19,7 @@ export const pikkuRemoteAuthMiddleware = pikkuMiddleware(async ({ secrets, jwt }
         secret = (await secrets.getSecret('PIKKU_REMOTE_SECRET')).reveal();
     }
     catch {
-        if (http.request.path().startsWith('/remote/rpc/')) {
+        if (isRemoteRpcPath(http.request.path())) {
             throw new UnauthorizedError();
         }
         return next();
@@ -38,8 +47,10 @@ export const pikkuRemoteAuthMiddleware = pikkuMiddleware(async ({ secrets, jwt }
     if (payload?.aud !== 'pikku-remote') {
         throw new UnauthorizedError();
     }
-    if (payload?.fn && http.request.path().startsWith('/remote/rpc/')) {
-        const fn = decodeURIComponent(http.request.path().slice('/remote/rpc/'.length));
+    if (payload?.fn && isRemoteRpcPath(http.request.path())) {
+        // The prefix length is the same in any case, so slicing the raw path
+        // keeps the requested function name in its original case for the compare.
+        const fn = decodeURIComponent(http.request.path().slice(REMOTE_RPC_PREFIX.length));
         if (fn && payload.fn !== fn) {
             throw new UnauthorizedError();
         }

package/dist/permissions.d.ts

@@ -1,20 +1,18 @@
 import type { CoreServices, CoreUserSession, PikkuWire } from './types/core.types.js';
+import type { PikkuRPC } from './wirings/rpc/rpc-types.js';
+/**
+ * The wire a permission function sees. `Out = never` denies it `channel.send`.
+ *
+ * knowledge: decisions/security/a-permission-gets-a-wire-it-cannot-reply-on.md
+ */
+export type PermissionWire = PikkuWire<any, never, false, any, PikkuRPC, never, never>;
 import type { CorePermissionGroup, CorePikkuPermission } from './function/functions.types.js';
 export declare const clearPermissionsCache: () => void;
 export declare const addGlobalPermission: (permissions: CorePermissionGroup | CorePikkuPermission[], packageName?: string | null) => CorePermissionGroup | CorePikkuPermission[];
-/**
- * @deprecated Tag-level permissions were removed in #972 — permissions are now
- * function-scoped only (declare them on the function via `pikkuFunc({ permissions })`).
- * This throwing stub exists solely so the pinned bootstrap CLI (which still
- * generates an `addTagPermission` wrapper) can resolve the import at build time;
- * it is never called. Delete once `PIKKU_CLI_VERSION` in the CLI build is bumped
- * past the release that removes tag permissions.
- */
-export declare const addTagPermission: (_tag: string, _permissions: CorePermissionGroup | CorePikkuPermission[], _packageName?: string | null) => never;
 export declare const runPermissions: ({ funcPermissions, services, wire, data, packageName, label, }: {
     funcPermissions?: CorePermissionGroup | CorePikkuPermission[];
     services: CoreServices;
-    wire: PikkuWire<any, never, any, CoreUserSession, never, never, never>;
+    wire: PermissionWire;
     data: any;
     packageName?: string | null;
     /** What the non-global gate is called in debug logs, e.g. 'function', 'agent'. */

package/dist/permissions.js

@@ -40,17 +40,6 @@ export const addGlobalPermission = (permissions, packageName = null) => {
     clearPermissionsCache();
     return permissions;
 };
-/**
- * @deprecated Tag-level permissions were removed in #972 — permissions are now
- * function-scoped only (declare them on the function via `pikkuFunc({ permissions })`).
- * This throwing stub exists solely so the pinned bootstrap CLI (which still
- * generates an `addTagPermission` wrapper) can resolve the import at build time;
- * it is never called. Delete once `PIKKU_CLI_VERSION` in the CLI build is bumped
- * past the release that removes tag permissions.
- */
-export const addTagPermission = (_tag, _permissions, _packageName = null) => {
-    throw new Error('addTagPermission was removed in #972 — tag-level permissions no longer exist. Declare permissions on the function definition instead: pikkuFunc({ permissions }).');
-};
 const bucket = (packageName) => pikkuState(packageName, 'permissions', 'global') ?? [];
 /**
  * Global permissions in effect for a function, root ones first.

package/dist/pikku-state.js

@@ -1,10 +1,17 @@
 const PIKKU_STATE_KEY = Symbol.for('@pikku/core/state');
+/**
+ * State is parked on `globalThis` under a registered symbol so separate copies
+ * of @pikku/core in one process share it. Typed once here rather than at each
+ * access.
+ */
+const stateHost = globalThis;
 export const getAllPackageStates = () => {
-    if (!globalThis[PIKKU_STATE_KEY]) {
-        ;
-        globalThis[PIKKU_STATE_KEY] = new Map();
+    let states = stateHost[PIKKU_STATE_KEY];
+    if (!states) {
+        states = new Map();
+        stateHost[PIKKU_STATE_KEY] = states;
     }
-    return globalThis[PIKKU_STATE_KEY];
+    return states;
 };
 export const pikkuState = (packageName, type, content, value) => {
     const resolvedPackageName = packageName ?? '__main__';
@@ -77,6 +84,9 @@ const createEmptyPackageState = () => ({
     agent: {
         agents: new Map(),
         agentsMeta: {},
+        scorers: new Map(),
+        scorersMeta: {},
+        modelAliases: {},
     },
     gateway: {
         gateways: new Map(),
@@ -110,6 +120,7 @@ const createEmptyPackageState = () => ({
         authFactory: null,
         credentialsMeta: null,
         requiredParentServices: null,
+        declaredSecrets: null,
     },
 });
 export const initializePikkuState = (packageName) => {
@@ -120,7 +131,7 @@ export const initializePikkuState = (packageName) => {
 export const resetPikkuState = () => {
     // Error definitions come from module-import side effects that never re-run.
     const existingErrors = getAllPackageStates().get('__main__')?.misc.errors;
-    globalThis[PIKKU_STATE_KEY] = new Map();
+    stateHost[PIKKU_STATE_KEY] = new Map();
     initializePikkuState('__main__');
     if (existingErrors) {
         const mainState = getAllPackageStates().get('__main__');

package/dist/schema.js

@@ -98,6 +98,40 @@ export const coerceTopLevelDataFromSchema = (schemaName, data, packageName = nul
         }
     }
 };
+/**
+ * Drops object properties whose value is literally `undefined`.
+ *
+ * JSON Schema has no way to describe such a property, and the validator refuses
+ * the whole instance rather than reporting it — `{ a: undefined }` throws
+ * "Instances of \"undefined\" type are not supported" instead of validating.
+ *
+ * That matters because whether a payload can contain one depends on how the
+ * call travelled. Over HTTP `JSON.stringify` drops these keys before the
+ * request is built, so they never arrive. Dispatched in-process — an inline
+ * workflow step calling an RPC — the object is handed over as-is, and
+ * `{ retries: data.maybeRetries }` with the field omitted by the caller is
+ * enough to kill the step. Normalising here makes the two paths agree, and an
+ * explicitly-undefined *required* field now reports as the missing property it
+ * is rather than as an internal error.
+ *
+ * Deliberately not a JSON round-trip: `coerceTopLevelDataFromSchema` puts real
+ * `Date` instances on the data first, and stringifying would flatten them back
+ * to strings the validator has never been given.
+ */
+const stripUndefinedValues = (value) => {
+    if (Array.isArray(value))
+        return value.map(stripUndefinedValues);
+    if (value === null || typeof value !== 'object')
+        return value;
+    // Only plain objects: a Date, Map or class instance is data, not a bag of
+    // properties to be rewritten.
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, entry]) => entry !== undefined)
+        .map(([key, entry]) => [key, stripUndefinedValues(entry)]));
+};
 export const validateSchema = async (logger, schemaService, schemaName, data, packageName = null) => {
     if (schemaService) {
         if (!schemaName) {
@@ -118,6 +152,6 @@ export const validateSchema = async (logger, schemaService, schemaName, data, pa
             throw new MissingSchemaError(`Schema '${schemaName}' not found. Ensure schema generation has been run.`);
         }
         await schemaService.compileSchema(key, schema);
-        await schemaService.validateSchema(key, data ?? {});
+        await schemaService.validateSchema(key, stripUndefinedValues(data ?? {}));
     }
 };

package/dist/services/ai-agent-runner-service.d.ts

@@ -54,6 +54,13 @@ export type AIAgentStepResult = {
         toolCallId: string;
         toolName: string;
         result: unknown;
+        /**
+         * Set when the tool threw rather than returned. Carried as its own field
+         * because `result` is a rendered string by the time anything downstream
+         * reads it, and "did this tool fail" is not answerable by looking for an
+         * `Error:` prefix in text a tool could legitimately have returned.
+         */
+        error?: string;
     }[];
     usage: {
         inputTokens: number;

package/dist/services/ai-run-state-service.d.ts

@@ -1,13 +1,29 @@
 import type { AgentRunState, PendingApproval } from '../wirings/ai-agent/ai-agent.types.js';
+import type { AIRunScore } from '../wirings/ai-scorer/ai-scorer.types.js';
 export type CreateRunInput = Omit<AgentRunState, 'runId'>;
+export type SaveScoreInput = Omit<AIRunScore, 'createdAt'>;
 export interface AIRunStateService {
     createRun(run: CreateRunInput): Promise<string>;
     updateRun(runId: string, updates: Partial<AgentRunState>): Promise<void>;
     getRun(runId: string): Promise<AgentRunState | null>;
     getRunsByThread(threadId: string): Promise<AgentRunState[]>;
-    resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<void>;
+    /**
+     * Claims an approval: removes it from the run's pending list and records the
+     * decision, as one atomic step. Returns whether THIS caller made the claim —
+     * concurrent approvals of the same tool call produce exactly one `true`, and
+     * only that caller may run the tool.
+     */
+    resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<boolean>;
     findRunByToolCallId(toolCallId: string): Promise<{
         run: AgentRunState;
         approval: PendingApproval;
     } | null>;
+    /**
+     * Record one scorer's grade of a finished run. A run accumulates one row per
+     * scorer, and a scorer may grade the same run more than once — a retried job
+     * appends rather than replaces, so a re-grade never silently overwrites the
+     * grade that was acted on.
+     */
+    saveScore(score: SaveScoreInput): Promise<void>;
+    getScores(runId: string): Promise<AIRunScore[]>;
 }

package/dist/services/in-memory-ai-run-state-service.d.ts

@@ -1,15 +1,19 @@
-import type { AIRunStateService, CreateRunInput } from './ai-run-state-service.js';
+import type { AIRunStateService, CreateRunInput, SaveScoreInput } from './ai-run-state-service.js';
 import type { AgentRunState, PendingApproval } from '../wirings/ai-agent/ai-agent.types.js';
+import type { AIRunScore } from '../wirings/ai-scorer/ai-scorer.types.js';
 export declare class InMemoryAIRunStateService implements AIRunStateService {
     private runs;
+    private scores;
     private counter;
     createRun(run: CreateRunInput): Promise<string>;
     updateRun(runId: string, updates: Partial<AgentRunState>): Promise<void>;
     getRun(runId: string): Promise<AgentRunState | null>;
     getRunsByThread(threadId: string): Promise<AgentRunState[]>;
-    resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<void>;
+    resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<boolean>;
     findRunByToolCallId(toolCallId: string): Promise<{
         run: AgentRunState;
         approval: PendingApproval;
     } | null>;
+    saveScore(score: SaveScoreInput): Promise<void>;
+    getScores(runId: string): Promise<AIRunScore[]>;
 }