@pikku/core 0.12.136 → 0.12.138

package/dist/utils/hmac.js

@@ -1,42 +1,220 @@
-import { createHmac, createVerify, timingSafeEqual } from 'node:crypto';
+/**
+ * Web Crypto only: no `node:crypto` and no `Buffer`, so this loads on edge
+ * runtimes. Web Crypto is async, so everything that touches a key returns a
+ * Promise; `timingSafeStringEqual` is plain JS and stays synchronous.
+ */
+const encoder = new TextEncoder();
+const subtle = () => {
+    const s = globalThis.crypto?.subtle;
+    if (!s)
+        throw new Error('WebCrypto not available');
+    return s;
+};
+const bytesToHex = (bytes) => {
+    let out = '';
+    for (const b of bytes)
+        out += b.toString(16).padStart(2, '0');
+    return out;
+};
+const bytesToBase64 = (bytes) => {
+    let binary = '';
+    for (const b of bytes)
+        binary += String.fromCharCode(b);
+    return btoa(binary);
+};
+/** Lenient like Node's `Buffer.from(_, 'hex')`: stops at the first bad pair. */
+const hexToBytes = (hex) => {
+    const out = [];
+    for (let i = 0; i + 1 < hex.length; i += 2) {
+        const pair = hex.slice(i, i + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(pair))
+            break;
+        out.push(parseInt(pair, 16));
+    }
+    return Uint8Array.from(out);
+};
+/** Lenient like Node's `Buffer.from(_, 'base64')`: accepts base64url, ignores junk. */
+const base64ToBytes = (value) => {
+    let clean = value
+        .replace(/-/g, '+')
+        .replace(/_/g, '/')
+        .replace(/[^A-Za-z0-9+/]/g, '');
+    if (clean.length % 4 === 1)
+        clean = clean.slice(0, -1);
+    clean += '='.repeat((4 - (clean.length % 4)) % 4);
+    const binary = atob(clean);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        out[i] = binary.charCodeAt(i);
+    return out;
+};
+/**
+ * Constant-time string comparison (pure JS; for opaque tokens, not HMACs, which
+ * `verifyHmacSignature` checks with Web Crypto). Returns false on a length mismatch
+ * (the lengths of the two values are not secret).
+ */
+export function timingSafeStringEqual(a, b) {
+    const left = encoder.encode(a);
+    const right = encoder.encode(b);
+    if (left.length !== right.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < left.length; i++)
+        diff |= left[i] ^ right[i];
+    return diff === 0;
+}
+const HMAC_HASH = {
+    sha1: 'SHA-1',
+    sha256: 'SHA-256',
+    sha512: 'SHA-512',
+};
+const rawSecretBytes = (secret, encoding) => encoding === 'hex'
+    ? hexToBytes(secret)
+    : encoding === 'base64'
+        ? base64ToBytes(secret)
+        : encoder.encode(secret);
+const secretBytes = (secret, encoding) => {
+    const bytes = rawSecretBytes(secret, encoding);
+    // Web Crypto refuses a zero-length key. HMAC zero-pads the key to the block
+    // size, so a single zero byte is the same key as an empty one. Only signing
+    // reaches here: verification refuses an empty key outright.
+    return bytes.length ? bytes : new Uint8Array(1);
+};
+const hmacBytes = async (secret, algorithm, payload, secretEncoding = 'utf8') => {
+    const hash = HMAC_HASH[algorithm];
+    if (!hash)
+        throw new Error(`Unsupported HMAC algorithm '${algorithm}'`);
+    const key = await subtle().importKey('raw', secretBytes(secret, secretEncoding), { name: 'HMAC', hash }, false, ['sign']);
+    const data = typeof payload === 'string' ? encoder.encode(payload) : payload;
+    return new Uint8Array(await subtle().sign('HMAC', key, data));
+};
 /**
  * HMAC-SHA256 of a payload, hex-encoded. Senders wrap this in their own scheme
  * prefix (`sha256=`, `v0=`, …).
  */
-export function hmacSha256Hex(secret, payload) {
-    return createHmac('sha256', secret).update(payload).digest('hex');
+export async function hmacSha256Hex(secret, payload) {
+    return bytesToHex(await hmacBytes(secret, 'sha256', payload));
+}
+/** The HMAC of `payload` under `secret`, for handshakes that answer with a digest. */
+export async function hmacDigest(secret, algorithm, payload, encoding, secretEncoding = 'utf8') {
+    const digest = await hmacBytes(secret, algorithm, payload, secretEncoding);
+    return encoding === 'hex' ? bytesToHex(digest) : bytesToBase64(digest);
 }
 /**
- * Constant-time signature comparison. Returns false on a length mismatch,
- * where `timingSafeEqual` itself throws.
+ * Whether `signature` is the HMAC of `payload` under `secret`. Fails closed on
+ * an empty secret (or one that decodes to an empty key) and on a missing or
+ * malformed signature. The comparison is `crypto.subtle.verify('HMAC', ...)`,
+ * so it runs in the platform's constant-time implementation.
  */
-export function timingSafeStringEqual(a, b) {
+export async function verifyHmacSignature(secret, signature, algorithm, payload, encoding, secretEncoding = 'utf8') {
+    if (!secret || !signature)
+        return false;
     try {
-        return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+        const hash = HMAC_HASH[algorithm];
+        if (!hash)
+            return false;
+        const keyBytes = rawSecretBytes(secret, secretEncoding);
+        if (!keyBytes.length)
+            return false;
+        if (encoding === 'hex' && !/^(?:[0-9a-fA-F]{2})+$/.test(signature)) {
+            return false;
+        }
+        const sig = encoding === 'hex' ? hexToBytes(signature) : base64ToBytes(signature);
+        if (!sig.length)
+            return false;
+        const key = await subtle().importKey('raw', keyBytes, { name: 'HMAC', hash }, false, ['verify']);
+        const data = typeof payload === 'string' ? encoder.encode(payload) : payload;
+        return await subtle().verify('HMAC', key, sig, data);
     }
     catch {
         return false;
     }
 }
-/** The HMAC of `payload` under `secret`, for handshakes that answer with a digest. */
-export function hmacDigest(secret, algorithm, payload, encoding, secretEncoding = 'utf8') {
-    return createHmac(algorithm, Buffer.from(secret, secretEncoding))
-        .update(payload)
-        .digest(encoding);
-}
-/** Whether `signature` is the HMAC of `payload` under `secret`, compared in constant time. */
-export function verifyHmacSignature(secret, signature, algorithm, payload, encoding, secretEncoding = 'utf8') {
-    return (!!signature &&
-        timingSafeStringEqual(signature, hmacDigest(secret, algorithm, payload, encoding, secretEncoding)));
-}
-/** Whether `signature` (base64) is `payload` signed by the private half of `publicKey` (PEM). */
-export function verifyPublicKeySignature(publicKey, signature, payload, options = {}) {
-    if (!signature)
+// DER prefixes of the SPKI algorithm identifiers we can import.
+const OID_RSA = '06092a864886f70d010101';
+const OID_EC = '06072a8648ce3d0201';
+const OID_ED25519 = '06032b6570';
+const EC_CURVES = {
+    '06082a8648ce3d030107': { name: 'P-256', size: 32 },
+    '06052b81040022': { name: 'P-384', size: 48 },
+    '06052b81040023': { name: 'P-521', size: 66 },
+};
+const SIGNATURE_HASH = {
+    sha1: 'SHA-1',
+    sha256: 'SHA-256',
+    sha384: 'SHA-384',
+    sha512: 'SHA-512',
+};
+const pemToDer = (pem) => base64ToBytes(pem.replace(/-----[A-Z ]+-----/g, '').replace(/\s+/g, ''));
+/** Reads an ASN.1 DER length at `offset`; returns [length, bytesUsed]. */
+const readLength = (der, offset) => {
+    const first = der[offset];
+    if (first < 0x80)
+        return [first, 1];
+    const count = first & 0x7f;
+    let length = 0;
+    for (let i = 0; i < count; i++)
+        length = (length << 8) | der[offset + 1 + i];
+    return [length, 1 + count];
+};
+/** An ECDSA signature as DER `SEQUENCE { r, s }` to the fixed-width `r || s` Web Crypto expects. */
+const derToP1363 = (der, size) => {
+    if (der[0] !== 0x30)
+        throw new Error('Invalid DER signature');
+    let offset = 1 + readLength(der, 1)[1];
+    const out = new Uint8Array(size * 2);
+    for (let part = 0; part < 2; part++) {
+        if (der[offset] !== 0x02)
+            throw new Error('Invalid DER signature');
+        const [length, used] = readLength(der, offset + 1);
+        let integer = der.slice(offset + 1 + used, offset + 1 + used + length);
+        while (integer.length > size && integer[0] === 0)
+            integer = integer.slice(1);
+        if (integer.length > size)
+            throw new Error('Invalid DER signature');
+        out.set(integer, part * size + (size - integer.length));
+        offset += 1 + used + length;
+    }
+    return out;
+};
+/**
+ * Whether `signature` (base64) is `payload` signed by the private half of
+ * `publicKey` (an RSA, EC or Ed25519 PEM `SPKI` key). RSA-PSS keys are not
+ * supported and verify as false. Ed25519 ignores `algorithm` and `dsaEncoding`.
+ */
+export async function verifyPublicKeySignature(publicKey, signature, payload, options = {}) {
+    if (!publicKey || !signature)
         return false;
     try {
-        return createVerify(options.algorithm ?? 'sha256')
-            .update(payload)
-            .verify({ key: publicKey, dsaEncoding: options.dsaEncoding }, signature, 'base64');
+        const der0 = pemToDer(publicKey);
+        if (bytesToHex(der0).includes(OID_ED25519)) {
+            const key = await subtle().importKey('spki', der0, { name: 'Ed25519' }, false, ['verify']);
+            return await subtle().verify({ name: 'Ed25519' }, key, base64ToBytes(signature), (typeof payload === 'string'
+                ? encoder.encode(payload)
+                : payload));
+        }
+        const hash = SIGNATURE_HASH[(options.algorithm ?? 'sha256')
+            .toLowerCase()
+            .replace(/^rsa-/, '')
+            .replace(/-/g, '')];
+        if (!hash)
+            return false;
+        const der = pemToDer(publicKey);
+        const hex = bytesToHex(der);
+        const data = typeof payload === 'string' ? encoder.encode(payload) : payload;
+        const sig = base64ToBytes(signature);
+        if (hex.includes(OID_RSA)) {
+            const key = await subtle().importKey('spki', der, { name: 'RSASSA-PKCS1-v1_5', hash }, false, ['verify']);
+            return await subtle().verify('RSASSA-PKCS1-v1_5', key, sig, data);
+        }
+        const curve = hex.includes(OID_EC)
+            ? Object.entries(EC_CURVES).find(([oid]) => hex.includes(oid))?.[1]
+            : undefined;
+        if (!curve)
+            return false;
+        const key = await subtle().importKey('spki', der, { name: 'ECDSA', namedCurve: curve.name }, false, ['verify']);
+        const raw = options.dsaEncoding === 'ieee-p1363' ? sig : derToP1363(sig, curve.size);
+        return await subtle().verify({ name: 'ECDSA', hash }, key, raw, data);
     }
     catch {
         return false;

package/dist/wirings/agent/agent-agui.js

@@ -27,59 +27,62 @@ export function wrapChannelWithAGUI(inner, options) {
     let sawUsage = false;
     let usageModel;
     const usageTotals = { input: 0, output: 0 };
-    function send(event) {
+    async function send(event) {
         if (!runStartedSent) {
             runStartedSent = true;
-            inner.send({
+            await inner.send({
                 type: 'RUN_STARTED',
                 threadId,
                 runId: resolveRunId(),
             });
         }
-        inner.send(event);
+        await inner.send(event);
     }
-    function endTextMessage() {
+    async function endTextMessage() {
         if (textMessageId) {
-            send({ type: 'TEXT_MESSAGE_END', messageId: textMessageId });
+            await send({ type: 'TEXT_MESSAGE_END', messageId: textMessageId });
             textMessageId = null;
         }
     }
-    function endThinkingMessage() {
+    async function endThinkingMessage() {
         if (thinkingMessageId) {
-            send({ type: 'THINKING_TEXT_MESSAGE_END', messageId: thinkingMessageId });
-            send({ type: 'THINKING_END' });
+            await send({
+                type: 'THINKING_TEXT_MESSAGE_END',
+                messageId: thinkingMessageId,
+            });
+            await send({ type: 'THINKING_END' });
             thinkingMessageId = null;
         }
     }
-    function endStep() {
+    async function endStep() {
         if (openStepName) {
-            send({ type: 'STEP_FINISHED', stepName: openStepName });
+            await send({ type: 'STEP_FINISHED', stepName: openStepName });
             openStepName = null;
         }
     }
-    function ensureTextMessage() {
+    async function ensureTextMessage() {
         if (!textMessageId) {
             textMessageId = randomUUID();
-            send({ type: 'TEXT_MESSAGE_START', messageId: textMessageId });
+            await send({ type: 'TEXT_MESSAGE_START', messageId: textMessageId });
         }
         return textMessageId;
     }
-    function ensureThinkingMessage() {
+    async function ensureThinkingMessage() {
         if (!thinkingMessageId) {
             thinkingMessageId = randomUUID();
-            send({ type: 'THINKING_START' });
-            send({
+            await send({ type: 'THINKING_START' });
+            await send({
                 type: 'THINKING_TEXT_MESSAGE_START',
                 messageId: thinkingMessageId,
             });
         }
         return thinkingMessageId;
     }
-    function finishRun() {
-        endTextMessage();
-        endThinkingMessage();
-        endStep();
-        send({
+    async function finishRun() {
+        await endTextMessage();
+        await endThinkingMessage();
+        await endStep();
+        await send({
             type: 'RUN_FINISHED',
             threadId,
             runId: resolveRunId(),
@@ -110,14 +113,14 @@ export function wrapChannelWithAGUI(inner, options) {
         remote: (funcName, data) => inner.remote(funcName, data),
         sendBinary: (data) => inner.sendBinary(data),
         close: () => inner.close(),
-        send: (event) => {
+        send: async (event) => {
             if (terminal)
                 return;
             switch (event.type) {
                 case 'text-delta': {
-                    endThinkingMessage();
-                    const id = ensureTextMessage();
-                    send({
+                    await endThinkingMessage();
+                    const id = await ensureTextMessage();
+                    await send({
                         type: 'TEXT_MESSAGE_CONTENT',
                         messageId: id,
                         delta: event.text,
@@ -125,9 +128,9 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'reasoning-delta': {
-                    endTextMessage();
-                    const id = ensureThinkingMessage();
-                    send({
+                    await endTextMessage();
+                    const id = await ensureThinkingMessage();
+                    await send({
                         type: 'THINKING_TEXT_MESSAGE_CONTENT',
                         messageId: id,
                         delta: event.text,
@@ -135,19 +138,19 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'tool-call': {
-                    endTextMessage();
-                    endThinkingMessage();
-                    send({
+                    await endTextMessage();
+                    await endThinkingMessage();
+                    await send({
                         type: 'TOOL_CALL_START',
                         toolCallId: event.toolCallId,
                         toolCallName: event.toolName,
                     });
-                    send({
+                    await send({
                         type: 'TOOL_CALL_ARGS',
                         toolCallId: event.toolCallId,
                         delta: resultToString(event.args) || '{}',
                     });
-                    send({
+                    await send({
                         type: 'TOOL_CALL_END',
                         toolCallId: event.toolCallId,
                         toolCallName: event.toolName,
@@ -155,7 +158,7 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'tool-result': {
-                    send({
+                    await send({
                         type: 'TOOL_CALL_RESULT',
                         messageId: randomUUID(),
                         toolCallId: event.toolCallId,
@@ -165,8 +168,8 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'usage': {
-                    endTextMessage();
-                    endThinkingMessage();
+                    await endTextMessage();
+                    await endThinkingMessage();
                     sawUsage = true;
                     usageTotals.input += event.tokens.input;
                     usageTotals.output += event.tokens.output;
@@ -175,30 +178,30 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'error': {
-                    endTextMessage();
-                    endThinkingMessage();
-                    endStep();
-                    send({ type: 'RUN_ERROR', message: event.message });
+                    await endTextMessage();
+                    await endThinkingMessage();
+                    await endStep();
+                    await send({ type: 'RUN_ERROR', message: event.message });
                     terminal = true;
                     break;
                 }
                 case 'done': {
-                    finishRun();
+                    await finishRun();
                     break;
                 }
                 case 'step-start': {
-                    endTextMessage();
-                    endThinkingMessage();
-                    endStep();
+                    await endTextMessage();
+                    await endThinkingMessage();
+                    await endStep();
                     stepSeq += 1;
                     openStepName = `${event.agent ?? 'step'}#${stepSeq}`;
-                    send({ type: 'STEP_STARTED', stepName: openStepName });
+                    await send({ type: 'STEP_STARTED', stepName: openStepName });
                     break;
                 }
                 case 'approval-request': {
-                    endTextMessage();
-                    endThinkingMessage();
-                    send({
+                    await endTextMessage();
+                    await endThinkingMessage();
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:approval-request',
                         value: {
@@ -214,9 +217,9 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'credential-request': {
-                    endTextMessage();
-                    endThinkingMessage();
-                    send({
+                    await endTextMessage();
+                    await endThinkingMessage();
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:credential-request',
                         value: {
@@ -234,7 +237,7 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'generative-ui': {
-                    send({
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:generative-ui',
                         value: { spec: event.spec },
@@ -242,7 +245,7 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'data': {
-                    send({
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:data',
                         value: { name: event.name, data: event.data },
@@ -250,7 +253,7 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'agent-call': {
-                    send({
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:agent-call',
                         value: {
@@ -262,7 +265,7 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'agent-result': {
-                    send({
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:agent-result',
                         value: {
@@ -274,7 +277,7 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'suspended': {
-                    send({
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:suspended',
                         value: { reason: event.reason, missingRpcs: event.missingRpcs },
@@ -282,10 +285,10 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'interrupted': {
-                    endTextMessage();
-                    endThinkingMessage();
-                    endStep();
-                    send({
+                    await endTextMessage();
+                    await endThinkingMessage();
+                    await endStep();
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:interrupted',
                         value: {
@@ -298,7 +301,7 @@ export function wrapChannelWithAGUI(inner, options) {
                 }
                 // knowledge: decisions/internals/agent-speech-travels-as-a-custom-agui-event.md
                 case 'audio-delta': {
-                    send({
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:audio-delta',
                         value: {
@@ -310,11 +313,11 @@ export function wrapChannelWithAGUI(inner, options) {
                     break;
                 }
                 case 'audio-done': {
-                    send({ type: 'CUSTOM', name: 'pikku:audio-done', value: {} });
+                    await send({ type: 'CUSTOM', name: 'pikku:audio-done', value: {} });
                     break;
                 }
                 case 'transcript': {
-                    send({
+                    await send({
                         type: 'CUSTOM',
                         name: 'pikku:transcript',
                         value: { text: event.text },

package/dist/wirings/agent/agent-interrupt.d.ts

@@ -1,3 +1,4 @@
+import { type AbortScope } from '../../function/abort-scope.js';
 import type { AgentStorageService } from '../../services/agent-storage-service.js';
 /**
  * Why an in-flight agent run was cut short.
@@ -126,7 +127,9 @@ export declare const getInFlightTools: (runId: string) => string[];
 export declare const trackToolExecution: <T extends {
     name: string;
     readonly?: boolean;
-    execute: (input: any) => Promise<any>;
+    execute: (input: any, options?: {
+        abortScope?: AbortScope;
+    }) => Promise<any>;
 }>(tools: T[], handle: InterruptibleRunHandle) => T[];
 export declare const trackInterruptNote: (threadId: string, write: Promise<void>) => void;
 /** Await an interrupted tool result still being written to this thread. */

package/dist/wirings/agent/agent-interrupt.js

@@ -1,5 +1,5 @@
 import { randomUUID } from './agent-utils.js';
-import { AbandonedError, runInAbortScope, } from '../../function/abort-scope.js';
+import { AbandonedError } from '../../function/abort-scope.js';
 /**
  * Thrown out of the step loop when a run is interrupted, so an interruption is
  * distinguishable from a genuine failure at the one `catch` that would
@@ -162,7 +162,7 @@ export const trackToolExecution = (tools, handle) => tools.map((tool) => {
     }
     return {
         ...tool,
-        execute: (input) => {
+        execute: (input, options) => {
             // Assumed to have changed something unless it says otherwise — the tool
             // that never declares its checkpoint is the one that cannot be assumed
             // harmless. `beginChanges()` can only ever make this more precise.
@@ -178,7 +178,7 @@ export const trackToolExecution = (tools, handle) => tools.map((tool) => {
                     call.mutating = true;
                 },
             };
-            return handle.trackTool(tool.name, randomUUID(), () => runInAbortScope(scope, () => tool.execute(input)), {
+            return handle.trackTool(tool.name, randomUUID(), () => tool.execute(input, { ...options, abortScope: scope }), {
                 get collectResult() {
                     return call.mutating;
                 },

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

@@ -1,4 +1,3 @@
-import { randomUUID } from 'crypto';
 export function resolveMemoryServices(agent, singletonServices) {
     const memoryConfig = agent.memory;
     const storage = memoryConfig?.storage
@@ -83,7 +82,7 @@ export async function loadContextMessages(memoryConfig, storage, input, workingM
         const workingMem = await workingMemoryStorage.getWorkingMemory(input.threadId, 'thread');
         const prompt = buildWorkingMemoryPrompt(workingMem, workingMemoryJsonSchema);
         contextMessages.push({
-            id: `wm-${randomUUID()}`,
+            id: `wm-${globalThis.crypto.randomUUID()}`,
             role: 'system',
             content: prompt,
             createdAt: new Date(),
@@ -99,9 +98,9 @@ export async function saveMessages(storage, threadId, resourceId, memoryConfig,
         const newMessages = userMessage ? [userMessage] : [];
         for (const step of result.steps) {
             if (step.toolCalls?.length) {
-                const toolCallIds = step.toolCalls.map(() => randomUUID());
+                const toolCallIds = step.toolCalls.map(() => globalThis.crypto.randomUUID());
                 newMessages.push({
-                    id: randomUUID(),
+                    id: globalThis.crypto.randomUUID(),
                     role: 'assistant',
                     toolCalls: step.toolCalls.map((tc, i) => ({
                         id: toolCallIds[i],
@@ -111,7 +110,7 @@ export async function saveMessages(storage, threadId, resourceId, memoryConfig,
                     createdAt: new Date(),
                 });
                 newMessages.push({
-                    id: randomUUID(),
+                    id: globalThis.crypto.randomUUID(),
                     role: 'tool',
                     toolResults: step.toolCalls.map((tc, i) => ({
                         id: toolCallIds[i],
@@ -132,7 +131,7 @@ export async function saveMessages(storage, threadId, resourceId, memoryConfig,
             ]
             : responseText;
         newMessages.push({
-            id: randomUUID(),
+            id: globalThis.crypto.randomUUID(),
             role: 'assistant',
             content: assistantContent || undefined,
             createdAt: new Date(),

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

@@ -1,9 +1,10 @@
 // knowledge: decisions/internals/agent-model-config-stays-a-single-resolution-seam.md
 import { pikkuState } from '../../pikku-state.js';
+import { readEnvVariable } from '../../env.js';
 const isProviderQualified = (model) => model.includes('/');
 /** `PIKKU_MODEL_ALIASES=cheap:openai/gpt-5-mini,tool:anthropic/claude-sonnet-5` */
 const envAliases = () => {
-    const raw = process.env.PIKKU_MODEL_ALIASES;
+    const raw = readEnvVariable('PIKKU_MODEL_ALIASES');
     if (!raw)
         return {};
     const aliases = {};