@pikku/core 0.12.148 → 0.12.150

package/dist/wirings/addon/define-plugin.d.ts

@@ -22,6 +22,16 @@ type StudioScreenBase = {
     layout?: 'bare';
     /** Hides the screen and its nav for viewers without access. The addon's functions must enforce the same scopes: hiding a screen is not access control. */
     scopes?: string[];
+    /**
+     * The agent that answers in Studio's chat panel while this screen is open.
+     * `'studio:<name>'` names an agent Studio ships (e.g. `'studio:knowledge'`);
+     * `pikku all` only checks its format. A bare name is an agent the addon ships:
+     * it resolves to `agents/<name>.md` in the addon package: the agent's
+     * instructions, which name the skills it follows. Its frontmatter has a
+     * `title` and a `description`, both message keys in the addon's catalog.
+     * Lowercase letters, digits and hyphens, starting with a letter. Leave it out and the chat is unchanged.
+     */
+    agent?: string;
 } & ({
     /** `'studio'` gives `/<path>`, `'team'` gives `/<team>/<path>`. */
     scope: 'studio' | 'team';

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

@@ -1,6 +1,6 @@
 import type { CoreUserSession, GetCredential } from '../../types/core.types.js';
 import type { CoreAgent, AgentInput, AgentToolDef, AgentMessage, AgentStreamChannel, PikkuAgentMiddlewareHooks, SessionScope } from './agent.types.js';
-import type { AgentRunnerParams } from '../../services/agent-runner-service.js';
+import type { AgentRunnerParams, AgentRunnerService } from '../../services/agent-runner-service.js';
 import { PikkuError } from '../../errors/error-handler.js';
 import type { SessionService } from '../../services/user-session-service.js';
 /**
@@ -155,11 +155,18 @@ export declare function buildToolDefs(params: RunAgentParams, agentSessionMap: M
     tools: AgentToolDef[];
     missingRpcs: string[];
 }>;
+/**
+ * The singleton `agentRunner`, keyed with the caller's `AI_API_KEY` credential when one is set.
+ * Every entry that calls the model (run, stream, approve, resume) goes through this.
+ */
+export declare function resolveAgentRunner(singletonServices: {
+    agentRunner?: AgentRunnerService;
+}, params: RunAgentParams): Promise<AgentRunnerService>;
 export declare function prepareAgentRun(agentName: string, input: AgentInput, params: RunAgentParams, agentSessionMap: Map<string, string>, streamContext?: StreamContext): Promise<{
     agent: CoreAgent;
     packageName: string | null;
     resolvedName: string;
-    agentRunner: import("../../services/agent-runner-service.js").AgentRunnerService;
+    agentRunner: AgentRunnerService;
     storage: import("../../services/agent-storage-service.js").AgentStorageService | undefined;
     memoryConfig: import("./agent.types.js").AgentMemoryConfig | undefined;
     threadId: string;

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

@@ -679,20 +679,28 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
     }
     return { tools, missingRpcs };
 }
-export async function prepareAgentRun(agentName, input, params, agentSessionMap, streamContext) {
-    const singletonServices = getSingletonServices();
-    const { agent, packageName, resolvedName } = resolveAgent(agentName);
-    await assertAgentAuthorized(agent, params, packageName);
-    let agentRunner = singletonServices.agentRunner;
+/**
+ * The singleton `agentRunner`, keyed with the caller's `AI_API_KEY` credential when one is set.
+ * Every entry that calls the model (run, stream, approve, resume) goes through this.
+ */
+export async function resolveAgentRunner(singletonServices, params) {
+    const agentRunner = singletonServices.agentRunner;
     if (!agentRunner) {
         throw new AIProviderNotConfiguredError();
     }
     if (params.getCredential && agentRunner.withApiKey) {
         const aiCredential = await params.getCredential('AI_API_KEY');
         if (aiCredential?.apiKey?.trim()) {
-            agentRunner = agentRunner.withApiKey(aiCredential.apiKey);
+            return agentRunner.withApiKey(aiCredential.apiKey);
         }
     }
+    return agentRunner;
+}
+export async function prepareAgentRun(agentName, input, params, agentSessionMap, streamContext) {
+    const singletonServices = getSingletonServices();
+    const { agent, packageName, resolvedName } = resolveAgent(agentName);
+    await assertAgentAuthorized(agent, params, packageName);
+    const agentRunner = await resolveAgentRunner(singletonServices, params);
     const { storage } = resolveMemoryServices(agent, singletonServices);
     const memoryConfig = agent.memory;
     const threadId = input.threadId;

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

@@ -50,7 +50,7 @@ export const createAgentRPC = (wire, options) => {
             await resumeAgent({ runId, ...input }, wrapChannelWithAGUI(streamingChannel(), { runId }), params(), streamOptions);
         },
         interrupt: async (runId, reason) => interruptAgent({ runId, ...(reason ? { reason } : {}) }, { sessionService: options.sessionService }),
-        approve: async (runId, approvals, expectedAgentName) => asRunResult(await resumeAgentSync(runId, approvals, { sessionService: options.sessionService }, expectedAgentName === undefined
+        approve: async (runId, approvals, expectedAgentName) => asRunResult(await resumeAgentSync(runId, approvals, params(), expectedAgentName === undefined
             ? undefined
             : mapAddonCall(wire.addonNamespace, expectedAgentName))),
     };

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

@@ -1,5 +1,5 @@
 import { saveMessages, resolveMemoryServices, loadContextMessages, trimMessages, getWorkingMemoryMiddleware, } from './agent-memory.js';
-import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, resolveOwnerResourceId, agentSessionScope, assertResourcePrincipalOwner, assertRunBelongsToAgent, assertAgentAuthorized, } from './agent-prepare.js';
+import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, resolveOwnerResourceId, agentSessionScope, assertResourcePrincipalOwner, assertRunBelongsToAgent, assertAgentAuthorized, resolveAgentRunner, } from './agent-prepare.js';
 import { checkForApprovals, appendStepMessages } from './agent-stream.js';
 import { AgentInterruptedError, isAbortError, persistOrphanedToolResults, registerInterruptibleRun, trackInterruptNote, trackToolExecution, } from './agent-interrupt.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
@@ -7,7 +7,6 @@ import { applyInputMiddleware, describeApprovals, notifyAfterStep, toAccumulated
 import { applyOutputMiddleware, finalizeAgentRun, lastUserMessageText, } from './agent-finalize.js';
 import { resolveModelConfig } from './agent-model-config.js';
 import { validateAgentOutput } from './agent-output.js';
-import { AIProviderNotConfiguredError } from '../../errors/errors.js';
 import { deniedToolResult, randomUUID } from './agent-utils.js';
 function stripNulls(obj) {
     if (obj === null)
@@ -308,10 +307,7 @@ export async function resumeAgentSync(runId, approvals, params, expectedAgentNam
     await assertAgentAuthorized(agent, params, packageName);
     const { storage } = resolveMemoryServices(agent, singletonServices);
     const memoryConfig = agent.memory;
-    const agentRunner = singletonServices.agentRunner;
-    if (!agentRunner) {
-        throw new AIProviderNotConfiguredError();
-    }
+    const agentRunner = await resolveAgentRunner(singletonServices, params);
     const approvedIds = new Set(approvals.filter((a) => a.approved).map((a) => a.toolCallId));
     const rejectedIds = new Set(approvals.filter((a) => !a.approved).map((a) => a.toolCallId));
     const savedPendingApprovals = [...(run.pendingApprovals ?? [])];

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

@@ -1,12 +1,11 @@
 import { finalizeAgentRun, lastUserMessageText } from './agent-finalize.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { applyInputMiddleware, describeApprovals } from './agent-turn.js';
-import { AIProviderNotConfiguredError } from '../../errors/errors.js';
 import { deniedToolResult, randomUUID } from './agent-utils.js';
 import { SPOKEN_TRANSCRIPT } from './voice-input.js';
 import { combineChannelMiddleware, wrapChannelWithMiddleware, } from '../../channel-middleware-runner.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 { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, createScopedChannel, resolveOwnerResourceId, agentSessionScope, assertResourceOwner, assertResourcePrincipalOwner, assertAgentAuthorized, resolveAgentRunner, 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) {
@@ -752,6 +751,7 @@ export async function resumeAgent(input, channel, params, options) {
     }
     const { agent, packageName, resolvedName } = resolveAgent(run.agentName);
     await assertAgentAuthorized(agent, params, packageName);
+    const agentRunner = await resolveAgentRunner(singletonServices, params);
     // 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.
@@ -761,10 +761,6 @@ export async function resumeAgent(input, channel, params, options) {
     }
     const { storage } = resolveMemoryServices(agent, singletonServices);
     const memoryConfig = agent.memory;
-    const agentRunner = singletonServices.agentRunner;
-    if (!agentRunner) {
-        throw new AIProviderNotConfiguredError();
-    }
     if (!input.approved) {
         if (pending.type === 'agent-call') {
             await agentRunState.updateRun(pending.agentRunId, { status: 'failed' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.148",
+  "version": "0.12.150",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",