@pikku/core 0.12.83 → 0.12.84

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

@@ -0,0 +1,16 @@
+import type { CoreAgent } from './agent.types.js';
+import type { AgentRunStateService } from '../../services/agent-run-state-service.js';
+import { type RunAgentParams } from './agent-prepare.js';
+export declare const addAgent: (agentName: string, agent: CoreAgent<any, any>, packageName?: string | null) => void;
+export declare function approveAgent(agentRunState: AgentRunStateService, runId: string, approvals: {
+    toolCallId: string;
+    approved: boolean;
+}[], expectedAgentName?: string, params?: RunAgentParams): Promise<{
+    status: 'resumed' | 'suspended';
+    runId: string;
+    approved: string[];
+    rejected: string[];
+    remainingApprovals: number;
+}>;
+export declare const getAgents: () => Map<string, CoreAgent>;
+export declare const getAgentsMeta: () => import("./agent.types.js").AgentsMeta;

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

@@ -0,0 +1,51 @@
+import { pikkuState } from '../../pikku-state.js';
+import { agentSessionScope, assertAgentAuthorized, assertResourcePrincipalOwner, resolveAgent, } from './agent-prepare.js';
+export const addAgent = (agentName, agent, packageName = null) => {
+    const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
+    const agentMeta = agentsMeta[agentName];
+    if (!agentMeta) {
+        console.warn(`[pikku] Skipping AI agent '${agentName}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
+    }
+    const agents = pikkuState(packageName, 'agent', 'agents');
+    if (agents.has(agentName)) {
+        throw new Error(`AI agent already exists: ${agentName}`);
+    }
+    agents.set(agentName, agent);
+};
+export async function approveAgent(agentRunState, runId, approvals, expectedAgentName, params = {}) {
+    if (!agentRunState)
+        throw new Error('AgentRunStateService not available');
+    const run = await agentRunState.getRun(runId);
+    if (!run)
+        throw new Error('Run not found: ' + runId);
+    assertResourcePrincipalOwner(params, agentSessionScope(run.agentName), run.resourceId, 'run');
+    if (expectedAgentName && run.agentName !== expectedAgentName) {
+        throw new Error(`Run ${runId} belongs to agent '${run.agentName}', not '${expectedAgentName}'`);
+    }
+    if (run.status !== 'suspended')
+        throw new Error('Run is not suspended: ' + run.status);
+    const { agent, packageName } = resolveAgent(run.agentName);
+    await assertAgentAuthorized(agent, params, packageName);
+    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 remaining = (run.pendingApprovals ?? []).filter((p) => !approvedIds.has(p.toolCallId) && !rejectedIds.has(p.toolCallId));
+    const hasApproved = approvedIds.size > 0;
+    await agentRunState.updateRun(runId, {
+        status: hasApproved ? 'running' : 'suspended',
+        pendingApprovals: remaining.length > 0 ? remaining : undefined,
+    });
+    return {
+        status: hasApproved ? 'resumed' : 'suspended',
+        runId,
+        approved: [...approvedIds],
+        rejected: [...rejectedIds],
+        remainingApprovals: remaining.length,
+    };
+}
+export const getAgents = () => {
+    return pikkuState(null, 'agent', 'agents');
+};
+export const getAgentsMeta = () => {
+    return pikkuState(null, 'agent', 'agentsMeta');
+};

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

@@ -0,0 +1,15 @@
+import type { PikkuRawWire } from '../../types/core.types.js';
+import type { SessionService } from '../../services/user-session-service.js';
+import type { CoreUserSession } from '../../types/core.types.js';
+import type { PikkuRPC } from '../rpc/rpc-types.js';
+export type AgentRPCOptions = {
+    sessionService?: SessionService<CoreUserSession>;
+};
+/**
+ * `wire.rpc.agent`, implemented.
+ *
+ * Lives here rather than in `rpc-runner` so the agent surface is one file next
+ * to the runner and stream code it delegates to, instead of a wing of the RPC
+ * primitive.
+ */
+export declare const createAgentRPC: (wire: PikkuRawWire, options: AgentRPCOptions) => PikkuRPC["agent"];

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

@@ -0,0 +1,53 @@
+import { runAgent, resumeAgentSync } from './agent-runner.js';
+import { streamAgent, resumeAgent, interruptAgent } from './agent-stream.js';
+import { wrapChannelWithAGUI } from './agent-agui.js';
+/**
+ * `wire.rpc.agent`, implemented.
+ *
+ * Lives here rather than in `rpc-runner` so the agent surface is one file next
+ * to the runner and stream code it delegates to, instead of a wing of the RPC
+ * primitive.
+ */
+export const createAgentRPC = (wire, options) => {
+    const params = () => ({
+        sessionService: options.sessionService,
+        getCredential: wire.getCredential?.bind(wire),
+    });
+    const streamingChannel = () => {
+        const channel = wire.channel;
+        if (!channel)
+            throw new Error('No channel available for streaming');
+        return channel;
+    };
+    /** `run` and `approve` return the same shape; only the call differs. */
+    const asRunResult = (result) => ({
+        runId: result.runId,
+        result: result.object ?? result.text,
+        usage: result.usage,
+        ...(result.status === 'suspended' && {
+            status: 'suspended',
+            pendingApprovals: result.pendingApprovals,
+        }),
+    });
+    return {
+        run: async (agentName, input) => asRunResult(await runAgent(agentName, input, params())),
+        stream: async (agentName, input, streamOptions) => {
+            let currentRunId;
+            await streamAgent(agentName, input, wrapChannelWithAGUI(streamingChannel(), {
+                threadId: input.threadId,
+                getRunId: () => currentRunId,
+            }), params(), undefined, {
+                ...streamOptions,
+                onRunCreated: (runId) => {
+                    currentRunId = runId;
+                    streamOptions?.onRunCreated?.(runId);
+                },
+            });
+        },
+        resume: async (runId, input, streamOptions) => {
+            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)),
+    };
+};

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

@@ -0,0 +1,7 @@
+import type { AgentInput, AgentOutput } from './agent.types.js';
+import { type RunAgentParams } from './agent-prepare.js';
+export declare function runAgent(agentName: string, input: AgentInput, params: RunAgentParams, agentSessionMap?: Map<string, string>): Promise<AgentOutput>;
+export declare function resumeAgentSync(runId: string, approvals: {
+    toolCallId: string;
+    approved: boolean;
+}[], params: RunAgentParams, expectedAgentName?: string): Promise<AgentOutput>;