@pikku/core 0.12.83 → 0.12.86

package/dist/wirings/{ai-agent/ai-agent-stream.js → agent/agent-stream.js}

@@ -1,14 +1,14 @@
-import { finalizeAgentRun, lastUserMessageText, } from './ai-agent-finalize.js';
+import { finalizeAgentRun, lastUserMessageText } from './agent-finalize.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
-import { applyInputMiddleware } from './ai-agent-turn.js';
+import { applyInputMiddleware } from './agent-turn.js';
 import { AIProviderNotConfiguredError } from '../../errors/errors.js';
-import { randomUUID } from './ai-agent-utils.js';
+import { deniedToolResult, randomUUID } from './agent-utils.js';
 import { SPOKEN_TRANSCRIPT } from './voice-input.js';
 import { combineChannelMiddleware, wrapChannelWithMiddleware, } from '../channel/channel-middleware-runner.js';
-import { resolveMemoryServices, loadContextMessages, trimMessages, getWorkingMemoryMiddleware, } from './ai-agent-memory.js';
-import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, createScopedChannel, resolveOwnerResourceId, agentSessionScope, assertResourceOwner, assertResourcePrincipalOwner, assertAgentAuthorized, ToolApprovalRequired, ToolCredentialRequired, APPROVAL_REQUIRED, CREDENTIAL_REQUIRED, } from './ai-agent-prepare.js';
-import { resolveModelConfig } from './ai-agent-model-config.js';
-import { getInFlightTools, isAbortError, persistOrphanedToolResults, registerInterruptibleRun, signalRunInterrupt, trackInterruptNote, trackToolExecution, } from './ai-agent-interrupt.js';
+import { resolveMemoryServices, loadContextMessages, trimMessages, getWorkingMemoryMiddleware, } from './agent-memory.js';
+import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, createScopedChannel, resolveOwnerResourceId, agentSessionScope, assertResourceOwner, assertResourcePrincipalOwner, assertAgentAuthorized, ToolApprovalRequired, ToolCredentialRequired, APPROVAL_REQUIRED, CREDENTIAL_REQUIRED, } from './agent-prepare.js';
+import { resolveModelConfig } from './agent-model-config.js';
+import { getInFlightTools, isAbortError, persistOrphanedToolResults, registerInterruptibleRun, signalRunInterrupt, trackInterruptNote, trackToolExecution, } from './agent-interrupt.js';
 function createPersistingChannel(parent, storage, threadId, logger) {
     let fullText = '';
     let stepText = '';
@@ -175,17 +175,17 @@ const warnedUnstreamedOutputHooks = new Set();
  * rewrites in `modifyOutput` only — a redaction hook, typically — is therefore
  * silently ineffective when the agent is streamed, and is told so once.
  */
-const warnUnstreamedOutputHooks = (agentName, aiMiddlewares, logger) => {
+const warnUnstreamedOutputHooks = (agentName, agentMiddlewares, logger) => {
     if (warnedUnstreamedOutputHooks.has(agentName))
         return;
-    const unstreamed = aiMiddlewares.some((mw) => mw.modifyOutput && !mw.modifyOutputStream);
+    const unstreamed = agentMiddlewares.some((mw) => mw.modifyOutput && !mw.modifyOutputStream);
     if (!unstreamed)
         return;
     warnedUnstreamedOutputHooks.add(agentName);
     logger?.warn(`Agent '${agentName}' has AI middleware with modifyOutput but no modifyOutputStream — modifyOutput does not apply to streamed runs. Implement modifyOutputStream to affect a streamed reply.`);
 };
-async function postStreamCleanup(persistingChannel, aiRunState, runId, run) {
-    await finalizeAgentRun(aiRunState, {
+async function postStreamCleanup(persistingChannel, agentRunState, runId, run) {
+    await finalizeAgentRun(agentRunState, {
         runId,
         agentName: run.agentName,
         threadId: run.threadId,
@@ -204,7 +204,7 @@ async function postStreamCleanup(persistingChannel, aiRunState, runId, run) {
     });
 }
 async function runStreamStepLoop(params) {
-    const { agent, runnerParams, maxSteps, agentRunner, streamChannel, channel, aiMiddlewares, } = params;
+    const { agent, runnerParams, maxSteps, agentRunner, streamChannel, channel, agentMiddlewares, } = params;
     const singletonServices = getSingletonServices();
     for (let step = 0; step < maxSteps; step++) {
         if (agent.prepareStep) {
@@ -224,7 +224,7 @@ async function runStreamStepLoop(params) {
         }
         channel.send({ type: 'step-start', stepNumber: step });
         const stepResult = await agentRunner.stream(runnerParams, streamChannel);
-        for (const mw of aiMiddlewares) {
+        for (const mw of agentMiddlewares) {
             if (mw.afterStep) {
                 await mw.afterStep(singletonServices, {
                     stepNumber: step,
@@ -291,7 +291,7 @@ export function checkForApprovals(stepResult, tools) {
 export function checkForCredentialRequests(stepResult) {
     const requests = [];
     for (const tr of stepResult.toolResults) {
-        // knowledge: decisions/security/ai-agent-credential-requests-are-symbol-branded.md
+        // knowledge: decisions/security/agent-credential-requests-are-symbol-branded.md
         if (tr.result &&
             typeof tr.result === 'object' &&
             CREDENTIAL_REQUIRED in tr.result) {
@@ -345,7 +345,7 @@ export function appendStepMessages(runnerParams, stepResult) {
         runnerParams.messages.push(toolMsg);
     }
 }
-function handleApprovals(approvals, runId, channel, aiRunState, persistingChannel) {
+function handleApprovals(approvals, runId, channel, agentRunState, persistingChannel) {
     return (async () => {
         await persistingChannel.flush();
         const pendingApprovals = approvals.map((err) => err.agentRunId
@@ -363,7 +363,7 @@ function handleApprovals(approvals, runId, channel, aiRunState, persistingChanne
                 toolName: err.toolName,
                 args: err.args,
             });
-        await aiRunState.updateRun(runId, {
+        await agentRunState.updateRun(runId, {
             status: 'suspended',
             suspendReason: 'approval',
             pendingApprovals,
@@ -383,7 +383,7 @@ function handleApprovals(approvals, runId, channel, aiRunState, persistingChanne
         channel.close();
     })();
 }
-function handleCredentialRequests(requests, runId, channel, aiRunState, persistingChannel) {
+function handleCredentialRequests(requests, runId, channel, agentRunState, persistingChannel) {
     return (async () => {
         await persistingChannel.flush();
         const pendingApprovals = requests.map((req) => ({
@@ -395,7 +395,7 @@ function handleCredentialRequests(requests, runId, channel, aiRunState, persisti
             credentialType: req.credentialType,
             connectUrl: req.connectUrl,
         }));
-        await aiRunState.updateRun(runId, {
+        await agentRunState.updateRun(runId, {
             status: 'suspended',
             suspendReason: 'credential',
             pendingApprovals,
@@ -416,7 +416,7 @@ function handleCredentialRequests(requests, runId, channel, aiRunState, persisti
         channel.close();
     })();
 }
-export async function streamAIAgent(agentName, input, channel, params, agentSessionMap, options) {
+export async function streamAgent(agentName, input, channel, params, agentSessionMap, options) {
     const sessionMap = agentSessionMap ?? new Map();
     const normalizedInput = {
         ...input,
@@ -426,12 +426,12 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
     const { agent, packageName, resolvedName, agentRunner, storage, memoryConfig, threadId, userMessage, runnerParams, maxSteps, missingRpcs, workingMemorySchemaName, } = await prepareAgentRun(agentName, normalizedInput, params, sessionMap, streamContext);
     runnerParams.agentId = agentName;
     const singletonServices = getSingletonServices();
-    const { aiRunState } = singletonServices;
-    if (!aiRunState) {
-        throw new Error('AIRunStateService not available in singletonServices');
+    const { agentRunState } = singletonServices;
+    if (!agentRunState) {
+        throw new Error('AgentRunStateService not available in singletonServices');
     }
     if (missingRpcs.length > 0) {
-        await aiRunState.createRun({
+        await agentRunState.createRun({
             agentName,
             threadId,
             resourceId: normalizedInput.resourceId,
@@ -446,18 +446,18 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
         channel.send({ type: 'done' });
         return '';
     }
-    const aiMiddlewares = [
+    const agentMiddlewares = [
         ...getWorkingMemoryMiddleware(memoryConfig, storage, {
             threadId,
             workingMemorySchemaName,
             logger: singletonServices.logger,
             schemaService: singletonServices.schema,
         }),
-        ...(agent.aiMiddleware ?? []),
+        ...(agent.agentMiddleware ?? []),
     ];
-    // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
+    // One bag per run, shared by every middleware — see PikkuAgentMiddlewareHooks.
     const sharedNotes = {};
-    const { messages: modifiedMessages, instructions: modifiedInstructions } = await applyInputMiddleware(aiMiddlewares, singletonServices, {
+    const { messages: modifiedMessages, instructions: modifiedInstructions } = await applyInputMiddleware(agentMiddlewares, singletonServices, {
         messages: runnerParams.messages,
         instructions: runnerParams.instructions,
     }, sharedNotes);
@@ -471,7 +471,7 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
     // knowledge: decisions/internals/thread-history-records-the-transcript-not-the-audio.md
     const lastModified = modifiedMessages[modifiedMessages.length - 1];
     const persistedUserMessage = lastModified?.id === userMessage.id ? lastModified : userMessage;
-    const runId = await aiRunState.createRun({
+    const runId = await agentRunState.createRun({
         agentName,
         threadId,
         resourceId: normalizedInput.resourceId,
@@ -490,8 +490,8 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
     if (storage) {
         await storage.saveMessages(threadId, [persistedUserMessage]);
     }
-    warnUnstreamedOutputHooks(agentName, aiMiddlewares, singletonServices.logger);
-    const streamMiddleware = aiMiddlewares
+    warnUnstreamedOutputHooks(agentName, agentMiddlewares, singletonServices.logger);
+    const streamMiddleware = agentMiddlewares
         .filter((mw) => mw.modifyOutputStream)
         .map((mw) => {
         const state = {};
@@ -571,17 +571,17 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
             streamChannel: outputChannel,
             persistingChannel,
             channel,
-            aiMiddlewares,
+            agentMiddlewares,
         });
         if (loopResult.outcome === 'approval') {
-            await handleApprovals(loopResult.approvals, runId, channel, aiRunState, persistingChannel);
+            await handleApprovals(loopResult.approvals, runId, channel, agentRunState, persistingChannel);
             return persistingChannel.fullText;
         }
         if (loopResult.outcome === 'credential') {
-            await handleCredentialRequests(loopResult.credentialRequests, runId, channel, aiRunState, persistingChannel);
+            await handleCredentialRequests(loopResult.credentialRequests, runId, channel, agentRunState, persistingChannel);
             return persistingChannel.fullText;
         }
-        await postStreamCleanup(persistingChannel, aiRunState, runId, {
+        await postStreamCleanup(persistingChannel, agentRunState, runId, {
             agentName,
             threadId,
             resourceId: input.resourceId,
@@ -598,7 +598,7 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
         const interruption = interruptHandle.interruption;
         if (interruption || isAbortError(err)) {
             await persistingChannel.flush({ interrupted: true });
-            await aiRunState.updateRun(runId, { status: 'interrupted' });
+            await agentRunState.updateRun(runId, { status: 'interrupted' });
             // Deliberately not awaited. A tool still running must not hold the stream
             // open — the whole point of barge-in is that the agent stops now — so the
             // note lands later and the next run on this thread waits for it instead.
@@ -615,7 +615,7 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
             channel.close();
             return persistingChannel.fullText;
         }
-        for (const mw of aiMiddlewares) {
+        for (const mw of agentMiddlewares) {
             if (mw.onError) {
                 try {
                     await mw.onError(singletonServices, {
@@ -627,7 +627,7 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
                 catch { }
             }
         }
-        await aiRunState.updateRun(runId, {
+        await agentRunState.updateRun(runId, {
             status: 'failed',
             errorMessage: err instanceof Error ? err.message : String(err),
         });
@@ -646,9 +646,9 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
 /**
  * Stop an in-flight run on behalf of a caller, after checking the run is theirs.
  *
- * Unlike {@link resumeAIAgent} this needs no channel: it does not continue the
+ * Unlike {@link resumeAgent} this needs no channel: it does not continue the
  * stream, it ends one. The `interrupted` event and the truncated message are
- * emitted by the original {@link streamAIAgent} call on its own channel, so this
+ * emitted by the original {@link streamAgent} call on its own channel, so this
  * can be reached over a plain RPC while the stream is held open elsewhere —
  * which is exactly the shape a voice barge-in needs.
  *
@@ -661,12 +661,12 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
  * Returns `false` when there was nothing to stop. Racing a run that finishes on
  * its own is the normal case in voice, so it is not an error.
  */
-export async function interruptAIAgent(input, params) {
-    const { aiRunState, logger } = getSingletonServices();
-    if (!aiRunState) {
-        throw new Error('AIRunStateService not available in singletonServices');
+export async function interruptAgent(input, params) {
+    const { agentRunState, logger } = getSingletonServices();
+    if (!agentRunState) {
+        throw new Error('AgentRunStateService not available in singletonServices');
     }
-    const run = await aiRunState.getRun(input.runId);
+    const run = await agentRunState.getRun(input.runId);
     if (!run) {
         throw new Error(`No run found for runId ${input.runId}`);
     }
@@ -683,13 +683,13 @@ export async function interruptAIAgent(input, params) {
     // model call does nothing to a tool already executing.
     return { stopped, inFlightTools: getInFlightTools(input.runId) };
 }
-export async function resumeAIAgent(input, channel, params, options) {
+export async function resumeAgent(input, channel, params, options) {
     const singletonServices = getSingletonServices();
-    const { aiRunState } = singletonServices;
-    if (!aiRunState) {
-        throw new Error('AIRunStateService not available in singletonServices');
+    const { agentRunState } = singletonServices;
+    if (!agentRunState) {
+        throw new Error('AgentRunStateService not available in singletonServices');
     }
-    const run = await aiRunState.getRun(input.runId);
+    const run = await agentRunState.getRun(input.runId);
     if (!run) {
         throw new Error(`No run found for runId ${input.runId}`);
     }
@@ -703,21 +703,21 @@ export async function resumeAIAgent(input, channel, params, options) {
     // The read above is not a claim — concurrent resumes all see the same pending
     // approval. `resolveApproval` is the claim, and the loser must not go on to
     // run the tool a second time.
-    const claimed = await aiRunState.resolveApproval(input.toolCallId, input.approved ? 'approved' : 'denied');
+    const claimed = await agentRunState.resolveApproval(input.toolCallId, input.approved ? 'approved' : 'denied');
     if (!claimed) {
         throw new Error(`Approval for toolCallId ${input.toolCallId} was already resolved by another caller`);
     }
     const { storage } = resolveMemoryServices(agent, singletonServices);
     const memoryConfig = agent.memory;
-    const agentRunner = singletonServices.aiAgentRunner;
+    const agentRunner = singletonServices.agentRunner;
     if (!agentRunner) {
         throw new AIProviderNotConfiguredError();
     }
     if (!input.approved) {
         if (pending.type === 'agent-call') {
-            await aiRunState.updateRun(pending.agentRunId, { status: 'failed' });
+            await agentRunState.updateRun(pending.agentRunId, { status: 'failed' });
         }
-        const denialResult = 'The user explicitly declined this action. Inform them that it was declined and do not retry.';
+        const denialResult = deniedToolResult();
         if (storage) {
             await storage.saveMessages(run.threadId, [
                 {
@@ -745,19 +745,19 @@ export async function resumeAIAgent(input, channel, params, options) {
                 : pending.agentName,
             result: denialResult,
         });
-        const updatedRun = await aiRunState.getRun(run.runId);
+        const updatedRun = await agentRunState.getRun(run.runId);
         const remaining = updatedRun?.pendingApprovals ?? [];
         if (remaining.length > 0) {
             channel.send({ type: 'done' });
             channel.close();
             return;
         }
-        await aiRunState.updateRun(run.runId, { status: 'running' });
-        await continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, aiRunState, options);
+        await agentRunState.updateRun(run.runId, { status: 'running' });
+        await continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, agentRunState, options);
         return;
     }
     if (pending.type === 'agent-call') {
-        const subRun = await aiRunState.getRun(pending.agentRunId);
+        const subRun = await agentRunState.getRun(pending.agentRunId);
         if (!subRun) {
             throw new Error(`Sub-agent run not found: ${pending.agentRunId}`);
         }
@@ -773,7 +773,7 @@ export async function resumeAIAgent(input, channel, params, options) {
             session: 'resume',
             input: null,
         });
-        await resumeAIAgent({
+        await resumeAgent({
             runId: pending.agentRunId,
             toolCallId: subPending.toolCallId,
             approved: true,
@@ -806,8 +806,8 @@ export async function resumeAIAgent(input, channel, params, options) {
             channel,
             options: { ...options, requiresToolApproval: false },
         };
-        const aiMiddlewaresForResume = agent.aiMiddleware ?? [];
-        const { tools } = await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewaresForResume);
+        const agentMiddlewaresForResume = agent.agentMiddleware ?? [];
+        const { tools } = await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, agentMiddlewaresForResume);
         const matchingTool = tools.find((t) => t.name === pending.toolName);
         if (!matchingTool) {
             throw new Error(`Tool "${pending.toolName}" not found in agent definition`);
@@ -853,17 +853,17 @@ export async function resumeAIAgent(input, channel, params, options) {
             ...(toolError ? { error: toolError } : {}),
         });
     }
-    const updatedRun = await aiRunState.getRun(run.runId);
+    const updatedRun = await agentRunState.getRun(run.runId);
     const remaining = updatedRun?.pendingApprovals ?? [];
     if (remaining.length > 0) {
         channel.send({ type: 'done' });
         channel.close();
         return;
     }
-    await aiRunState.updateRun(run.runId, { status: 'running' });
-    await continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, aiRunState, options);
+    await agentRunState.updateRun(run.runId, { status: 'running' });
+    await continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, agentRunState, options);
 }
-async function continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, aiRunState, options) {
+async function continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, agentRunState, options) {
     const singletonServices = getSingletonServices();
     const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
     const meta = agentsMeta[resolvedName];
@@ -880,22 +880,22 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
     const allMessages = [...contextMessages, ...messages];
     const trimmedMessages = trimMessages(allMessages);
     const instructions = await buildInstructions(resolvedName, packageName);
-    const aiMiddlewares = [
+    const agentMiddlewares = [
         ...getWorkingMemoryMiddleware(memoryConfig, storage, {
             threadId: run.threadId,
             workingMemorySchemaName,
             logger: singletonServices.logger,
             schemaService: singletonServices.schema,
         }),
-        ...(agent.aiMiddleware ?? []),
+        ...(agent.agentMiddleware ?? []),
     ];
-    // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
+    // One bag per run, shared by every middleware — see PikkuAgentMiddlewareHooks.
     const sharedNotes = {};
-    const { messages: modifiedMessages, instructions: modifiedInstructions } = await applyInputMiddleware(aiMiddlewares, singletonServices, { messages: trimmedMessages, instructions: instructions }, sharedNotes);
+    const { messages: modifiedMessages, instructions: modifiedInstructions } = await applyInputMiddleware(agentMiddlewares, singletonServices, { messages: trimmedMessages, instructions: instructions }, sharedNotes);
     // knowledge: decisions/internals/a-resumed-agent-turn-is-as-interruptible-as-the-first.md
     const interruptHandle = registerInterruptibleRun(run.runId);
-    warnUnstreamedOutputHooks(run.agentName, aiMiddlewares, singletonServices.logger);
-    const streamMiddleware = aiMiddlewares
+    warnUnstreamedOutputHooks(run.agentName, agentMiddlewares, singletonServices.logger);
+    const streamMiddleware = agentMiddlewares
         .filter((mw) => mw.modifyOutputStream)
         .map((mw) => {
         const state = {};
@@ -935,7 +935,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
         ? wrapChannelWithMiddleware({ channel: persistingChannel }, singletonServices, allChannelMiddleware).channel
         : persistingChannel;
     const streamContext = { channel, options };
-    const resumeTools = (await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewares)).tools;
+    const resumeTools = (await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, agentMiddlewares)).tools;
     const resolved = resolveModelConfig(resolvedName, agent);
     const maxSteps = resolved.maxSteps ?? 10;
     const runnerParams = {
@@ -962,17 +962,17 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
             streamChannel: wrappedChannel,
             persistingChannel,
             channel,
-            aiMiddlewares,
+            agentMiddlewares,
         });
         if (loopResult.outcome === 'approval') {
-            await handleApprovals(loopResult.approvals, run.runId, channel, aiRunState, persistingChannel);
+            await handleApprovals(loopResult.approvals, run.runId, channel, agentRunState, persistingChannel);
             return;
         }
         if (loopResult.outcome === 'credential') {
-            await handleCredentialRequests(loopResult.credentialRequests, run.runId, channel, aiRunState, persistingChannel);
+            await handleCredentialRequests(loopResult.credentialRequests, run.runId, channel, agentRunState, persistingChannel);
             return;
         }
-        await postStreamCleanup(persistingChannel, aiRunState, run.runId, {
+        await postStreamCleanup(persistingChannel, agentRunState, run.runId, {
             ...run,
             input: lastUserMessageText(runnerParams.messages),
         });
@@ -986,7 +986,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
         const interruption = interruptHandle.interruption;
         if (interruption || isAbortError(err)) {
             await persistingChannel.flush({ interrupted: true });
-            await aiRunState.updateRun(run.runId, { status: 'interrupted' });
+            await agentRunState.updateRun(run.runId, { status: 'interrupted' });
             if (storage) {
                 trackInterruptNote(run.threadId, persistOrphanedToolResults(interruptHandle, storage, run.threadId));
             }
@@ -1000,7 +1000,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
             channel.close();
             return;
         }
-        for (const mw of aiMiddlewares) {
+        for (const mw of agentMiddlewares) {
             if (mw.onError) {
                 try {
                     await mw.onError(singletonServices, {
@@ -1012,7 +1012,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
                 catch { }
             }
         }
-        await aiRunState.updateRun(run.runId, {
+        await agentRunState.updateRun(run.runId, {
             status: 'failed',
             errorMessage: err instanceof Error ? err.message : String(err),
         });

package/dist/wirings/{ai-agent/ai-agent-turn.d.ts → agent/agent-turn.d.ts}

@@ -1,7 +1,7 @@
 import type { CoreSingletonServices } from '../../types/core.types.js';
-import type { PikkuAIMiddlewareHooks } from './ai-agent.types.js';
+import type { PikkuAgentMiddlewareHooks } from './agent.types.js';
 /** Exactly what `modifyInput` accepts and returns, taken from the hook itself. */
-type TurnInput = Pick<Parameters<NonNullable<PikkuAIMiddlewareHooks['modifyInput']>>[1], 'messages' | 'instructions'>;
+type TurnInput = Pick<Parameters<NonNullable<PikkuAgentMiddlewareHooks['modifyInput']>>[1], 'messages' | 'instructions'>;
 /**
  * Run every `modifyInput` hook in order, threading each result into the next.
  *
@@ -10,14 +10,14 @@ type TurnInput = Pick<Parameters<NonNullable<PikkuAIMiddlewareHooks['modifyInput
  * caller keeps, because hooks use it to pass things forward (`voiceInput`
  * leaves the transcript there for `voiceOutput`).
  */
-export declare const applyInputMiddleware: (aiMiddlewares: PikkuAIMiddlewareHooks[], singletonServices: CoreSingletonServices, input: TurnInput, sharedNotes: Record<string, unknown>) => Promise<TurnInput>;
+export declare const applyInputMiddleware: (agentMiddlewares: PikkuAgentMiddlewareHooks[], singletonServices: CoreSingletonServices, input: TurnInput, sharedNotes: Record<string, unknown>) => Promise<TurnInput>;
 /** The step fields both agent paths hand to `afterStep`, taken from the hook. */
-type StepResult = Omit<Parameters<NonNullable<PikkuAIMiddlewareHooks['afterStep']>>[1], 'stepNumber'>;
+type StepResult = Omit<Parameters<NonNullable<PikkuAgentMiddlewareHooks['afterStep']>>[1], 'stepNumber'>;
 /**
  * Notify every `afterStep` hook. The payload is the step verbatim plus its
  * ordinal — a hook that wants the run's totals accumulates them itself.
  */
-export declare const notifyAfterStep: (aiMiddlewares: PikkuAIMiddlewareHooks[], singletonServices: CoreSingletonServices, stepNumber: number, stepResult: StepResult) => Promise<void>;
+export declare const notifyAfterStep: (agentMiddlewares: PikkuAgentMiddlewareHooks[], singletonServices: CoreSingletonServices, stepNumber: number, stepResult: StepResult) => Promise<void>;
 /**
  * The step shape kept on the run: each tool call paired with its result.
  *

package/dist/wirings/{ai-agent/ai-agent-turn.js → agent/agent-turn.js}

@@ -6,9 +6,9 @@
  * caller keeps, because hooks use it to pass things forward (`voiceInput`
  * leaves the transcript there for `voiceOutput`).
  */
-export const applyInputMiddleware = async (aiMiddlewares, singletonServices, input, sharedNotes) => {
+export const applyInputMiddleware = async (agentMiddlewares, singletonServices, input, sharedNotes) => {
     let { messages, instructions } = input;
-    for (const mw of aiMiddlewares) {
+    for (const mw of agentMiddlewares) {
         if (!mw.modifyInput)
             continue;
         const result = await mw.modifyInput(singletonServices, {
@@ -25,8 +25,8 @@ export const applyInputMiddleware = async (aiMiddlewares, singletonServices, inp
  * Notify every `afterStep` hook. The payload is the step verbatim plus its
  * ordinal — a hook that wants the run's totals accumulates them itself.
  */
-export const notifyAfterStep = async (aiMiddlewares, singletonServices, stepNumber, stepResult) => {
-    for (const mw of aiMiddlewares) {
+export const notifyAfterStep = async (agentMiddlewares, singletonServices, stepNumber, stepResult) => {
+    for (const mw of agentMiddlewares) {
         if (!mw.afterStep)
             continue;
         await mw.afterStep(singletonServices, {

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

@@ -0,0 +1,14 @@
+export declare const randomUUID: () => string;
+/**
+ * The tool result stored and streamed when a user denies an approval.
+ *
+ * Two readers, one string. The model needs the sentence — it has to tell the
+ * user the action was declined and not retry it. A client needs to know a
+ * denial when it sees one, so it can render the call as denied rather than as
+ * a successful call that happened to return prose; that is what `approved`
+ * carries, and it is the same flag a client sets optimistically the moment the
+ * deny button is clicked. Emitting only the sentence made the two disagree:
+ * live the call showed denied, and on any re-render from storage the same call
+ * came back green.
+ */
+export declare const deniedToolResult: () => string;

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

@@ -0,0 +1,17 @@
+export const randomUUID = () => globalThis.crypto.randomUUID();
+/**
+ * The tool result stored and streamed when a user denies an approval.
+ *
+ * Two readers, one string. The model needs the sentence — it has to tell the
+ * user the action was declined and not retry it. A client needs to know a
+ * denial when it sees one, so it can render the call as denied rather than as
+ * a successful call that happened to return prose; that is what `approved`
+ * carries, and it is the same flag a client sets optimistically the moment the
+ * deny button is clicked. Emitting only the sentence made the two disagree:
+ * live the call showed denied, and on any re-render from storage the same call
+ * came back green.
+ */
+export const deniedToolResult = () => JSON.stringify({
+    approved: false,
+    message: 'The user explicitly declined this action. Inform them that it was declined and do not retry.',
+});