@hold-rein/cli 0.0.0

package/dist/runtime/api/modules/agents/runtime/subagent-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-results.d.ts","sourceRoot":"","sources":["../../../../src/modules/agents/runtime/subagent-results.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,EAAwB,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAIrE,UAAU,2BAA2B;IACnC,wBAAwB,EAAE,CACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,OAAO,KACd,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB;AAED,wBAAgB,wBAAwB,CACtC,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,EAChD,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,IAAI,CAIN;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,SAAS,2BAA2B,EAC3C,KAAK,EAAE;IACP,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;IACxB,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;CAC9C,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhB;AAED,wBAAsB,oBAAoB,CACxC,OAAO,SAAS,2BAA2B,EAC3C,KAAK,EAAE;IACP,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,aAAa,CAAC;IACxB,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;CAChC,GAAG,OAAO,CAAC,MAAM,CAAC,CAiBlB"}

package/dist/runtime/api/modules/agents/runtime/subagent-results.js

@@ -0,0 +1,39 @@
+import { appendVisibleCustomMessage } from "./messages.js";
+import { formatSubagentResult } from "../subagent/index.js";
+const SUBAGENT_RESULT_CUSTOM_TYPE = "subagent_result";
+export function addPendingSubagentResult(pendingSubagentResults, agentId, subagentId) {
+    const pending = pendingSubagentResults.get(agentId) ?? new Set();
+    pending.add(subagentId);
+    pendingSubagentResults.set(agentId, pending);
+}
+export async function flushPendingSubagentResults(input) {
+    const pending = input.pendingSubagentResults.get(input.agentId);
+    if (!pending)
+        return;
+    for (const subagentId of pending) {
+        const subagent = input.subagents.get(subagentId);
+        if (subagent && !subagent.consumed) {
+            await appendSubagentResult({ ...input, subagent });
+            input.subagents.delete(subagentId);
+        }
+    }
+    input.pendingSubagentResults.delete(input.agentId);
+}
+export async function appendSubagentResult(input) {
+    const prompt = formatSubagentResult(input.subagent);
+    await appendVisibleCustomMessage({
+        agentId: input.agentId,
+        content: prompt,
+        customType: SUBAGENT_RESULT_CUSTOM_TYPE,
+        details: {
+            agentId: input.subagent.agentId,
+            agentName: input.subagent.agentName,
+            session: input.subagent.session
+        },
+        eventBus: input.eventBus,
+        session: input.session
+    });
+    input.subagent.consumed = true;
+    input.pendingSubagentResults.get(input.agentId)?.delete(input.subagent.agentId);
+    return prompt;
+}

package/dist/runtime/api/modules/agents/runtime/subagent-tools.d.ts

@@ -0,0 +1,49 @@
+import type { ServerPlugin } from "@hold-rein/plugin-server";
+import { type AppDatabase } from "../../../db";
+import type { AgentEventBus } from "../event/event-bus";
+import { type SubagentRun } from "../subagent";
+import type { SubagentRepository } from "../subagent/repository";
+import type { HarnessSession, PendingVisibleCustomMessage, StartHarnessOptions, StartHarnessResult } from "./type";
+type StartHarness = (promptText: string, harnessOptions: StartHarnessOptions) => Promise<StartHarnessResult>;
+interface CreateRuntimeSubagentToolsInput {
+    contributionTools: ServerPlugin.PluginTool[];
+    eventBus: AgentEventBus;
+    parentAgentId: string;
+    parentAgentName?: string;
+    parentSession: HarnessSession;
+    pendingVisibleMessages: Map<string, PendingVisibleCustomMessage[]>;
+    persistedSubagentRepository: SubagentRepository;
+    sessionRepo: SessionRepo;
+    startHarness: StartHarness;
+    subagentDatabase?: AppDatabase;
+    subagents: Map<string, SubagentRun<HarnessSession>>;
+    taskId: string;
+    workspacePath: string;
+}
+interface CreateRuntimeRevokeSubagentToolInput {
+    eventBus: AgentEventBus;
+    parentAgentId: string;
+    parentSession: HarnessSession;
+    persistedSubagentRepository: SubagentRepository;
+    sessionRepo: SessionRepo;
+    startHarness: StartHarness;
+    subagentDatabase?: AppDatabase;
+    subagents: Map<string, SubagentRun<HarnessSession>>;
+    taskId: string;
+    workspacePath: string;
+}
+interface SessionRepo {
+    create: (input: {
+        cwd: string;
+    }) => Promise<HarnessSession>;
+    open: (input: {
+        createdAt: string;
+        cwd: string;
+        id: string;
+        path: string;
+    }) => Promise<HarnessSession>;
+}
+export declare function createRuntimeSubagentTools(input: CreateRuntimeSubagentToolsInput): Promise<ServerPlugin.PluginTool[]>;
+export declare function createRuntimeRevokeSubagentTool(input: CreateRuntimeRevokeSubagentToolInput): ServerPlugin.PluginTool;
+export {};
+//# sourceMappingURL=subagent-tools.d.ts.map

package/dist/runtime/api/modules/agents/runtime/subagent-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-tools.d.ts","sourceRoot":"","sources":["../../../../src/modules/agents/runtime/subagent-tools.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,EAA+B,KAAK,WAAW,EAAoB,MAAM,aAAa,CAAC;AAC9F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAoD,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AACjG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,cAAc,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAInH,KAAK,YAAY,GAAG,CAClB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,mBAAmB,KAChC,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,UAAU,+BAA+B;IACvC,iBAAiB,EAAE,YAAY,CAAC,UAAU,EAAE,CAAC;IAC7C,QAAQ,EAAE,aAAa,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,cAAc,CAAC;IAC9B,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,2BAA2B,EAAE,CAAC,CAAC;IACnE,2BAA2B,EAAE,kBAAkB,CAAC;IAChD,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,CAAC,EAAE,WAAW,CAAC;IAC/B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,oCAAoC;IAC5C,QAAQ,EAAE,aAAa,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,cAAc,CAAC;IAC9B,2BAA2B,EAAE,kBAAkB,CAAC;IAChD,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,CAAC,EAAE,WAAW,CAAC;IAC/B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,WAAW;IACnB,MAAM,EAAE,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAC5D,IAAI,EAAE,CAAC,KAAK,EAAE;QACZ,SAAS,EAAE,MAAM,CAAC;QAClB,GAAG,EAAE,MAAM,CAAC;QACZ,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;KACd,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;CAC/B;AAED,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,+BAA+B,GACrC,OAAO,CAAC,YAAY,CAAC,UAAU,EAAE,CAAC,CAUpC;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,oCAAoC,GAC1C,YAAY,CAAC,UAAU,CAmEzB"}

package/dist/runtime/api/modules/agents/runtime/subagent-tools.js

@@ -0,0 +1,195 @@
+import { randomUUID } from "node:crypto";
+import { eq } from "drizzle-orm";
+import { subagents as subagentsTable } from "../../../db/index.js";
+import { createCallSubagentTool, createRevokeSubagentTool } from "../subagent/index.js";
+import { toAgentSessionMetadata } from "./support.js";
+const CALL_SUBAGENT_CUSTOM_TYPE = "callsubagent";
+export async function createRuntimeSubagentTools(input) {
+    const hasCalledSubagent = await sessionHasCalledSubagent(input.parentSession);
+    return [
+        ...input.contributionTools,
+        createCallSubagentTool({
+            startSubagent: (request) => startSubagent(input, request)
+        }),
+        ...(hasCalledSubagent ? [createRuntimeRevokeSubagentTool(input)] : [])
+    ];
+}
+export function createRuntimeRevokeSubagentTool(input) {
+    return createRevokeSubagentTool({
+        continueSubagent: async ({ agentId, prompt }) => {
+            const subagentRow = findSubagentRow(input.subagentDatabase, agentId);
+            if (!subagentRow ||
+                subagentRow.status !== "completed") {
+                throw new Error(`Unknown completed subagent: ${agentId}`);
+            }
+            const session = getPersistedSubagentSession(subagentRow);
+            if (!session) {
+                throw new Error(`Subagent session is missing: ${agentId}`);
+            }
+            const existingSubagent = input.subagents.get(agentId);
+            const agentName = existingSubagent?.agentName ?? subagentRow.agentName;
+            const agentSession = await input.sessionRepo.open({
+                ...session,
+                cwd: input.workspacePath
+            });
+            updateSubagentStatus(input.subagentDatabase, agentId, "running");
+            input.subagents.set(agentId, {
+                agentId,
+                agentName,
+                agentSession,
+                consumed: false,
+                lastAssistantText: "",
+                parentAgentId: input.parentAgentId,
+                parentSession: input.parentSession,
+                session,
+                status: "running"
+            });
+            input.eventBus.emit({
+                agentId: input.parentAgentId,
+                payload: {
+                    agentId,
+                    agentName,
+                    parentAgentId: input.parentAgentId,
+                    session,
+                    taskId: input.taskId
+                },
+                type: "subagent_resumed"
+            });
+            await input.startHarness(prompt, {
+                agentId,
+                agentName,
+                isContinue: true,
+                parentAgentId: input.parentAgentId,
+                pluginPrompt: prompt,
+                session: agentSession
+            });
+            return {
+                content: [{
+                        text: `Subagent "${agentName}" was revoked. agentId=${agentId}`,
+                        type: "text"
+                    }],
+                details: {
+                    agentId,
+                    agentName,
+                    parentAgentId: input.parentAgentId,
+                    session,
+                    taskId: input.taskId
+                }
+            };
+        }
+    });
+}
+function getPersistedSubagentSession(subagent) {
+    if (!subagent ||
+        !subagent.sessionCreatedAt ||
+        !subagent.sessionId ||
+        !subagent.sessionPath) {
+        return undefined;
+    }
+    return {
+        createdAt: subagent.sessionCreatedAt,
+        id: subagent.sessionId,
+        path: subagent.sessionPath
+    };
+}
+function findSubagentRow(database, agentId) {
+    if (!database) {
+        throw new Error("Subagent database is required to revoke a subagent");
+    }
+    return database.db
+        .select()
+        .from(subagentsTable)
+        .where(eq(subagentsTable.agentId, agentId))
+        .get();
+}
+function updateSubagentStatus(database, agentId, status) {
+    if (!database) {
+        throw new Error("Subagent database is required to update a subagent");
+    }
+    database.db
+        .update(subagentsTable)
+        .set({ status, updatedAt: new Date().toISOString() })
+        .where(eq(subagentsTable.agentId, agentId))
+        .run();
+}
+async function sessionHasCalledSubagent(session) {
+    const context = await session.buildContext();
+    return context.messages.some((message) => {
+        if (!message || typeof message !== "object")
+            return false;
+        const record = message;
+        return record.role === "custom" && record.customType === "callsubagent";
+    });
+}
+async function startSubagent(input, request) {
+    const agentId = `agent_${randomUUID()}`;
+    const createdAt = new Date().toISOString();
+    const childSession = await input.sessionRepo.create({
+        cwd: input.workspacePath
+    });
+    const childSessionMetadata = toAgentSessionMetadata(await childSession.getMetadata());
+    input.persistedSubagentRepository.create({
+        agentId,
+        agentName: request.agentName,
+        createdAt,
+        parentAgentId: input.parentAgentId,
+        sessionCreatedAt: childSessionMetadata.createdAt,
+        sessionId: childSessionMetadata.id,
+        sessionPath: childSessionMetadata.path,
+        status: "running",
+        taskId: input.taskId,
+        updatedAt: createdAt
+    });
+    let started;
+    try {
+        started = await input.startHarness(request.prompt, {
+            agentId,
+            agentName: request.agentName,
+            isContinue: false,
+            parentAgentId: input.parentAgentId,
+            pluginPrompt: request.prompt,
+            session: childSession
+        });
+    }
+    catch (error) {
+        input.persistedSubagentRepository.delete(agentId);
+        throw error;
+    }
+    const details = {
+        agentId: started.agentId,
+        agentName: request.agentName,
+        parentAgentId: input.parentAgentId,
+        session: started.session,
+        taskId: input.taskId
+    };
+    input.subagents.set(started.agentId, {
+        agentId: started.agentId,
+        agentName: request.agentName,
+        agentSession: started.harnessSession,
+        consumed: false,
+        lastAssistantText: "",
+        parentAgentId: input.parentAgentId,
+        ...(input.parentAgentName === undefined
+            ? {}
+            : { parentAgentName: input.parentAgentName }),
+        parentSession: input.parentSession,
+        session: started.session,
+        status: "running"
+    });
+    const pendingMessages = input.pendingVisibleMessages.get(request.toolCallId) ?? [];
+    pendingMessages.push({
+        content: `Subagent "${request.agentName}" is running.`,
+        customType: CALL_SUBAGENT_CUSTOM_TYPE,
+        details
+    });
+    input.pendingVisibleMessages.set(request.toolCallId, pendingMessages);
+    return {
+        content: [
+            {
+                text: `Subagent "${request.agentName}" is running. agentId=${started.agentId}`,
+                type: "text"
+            }
+        ],
+        details
+    };
+}

package/dist/runtime/api/modules/agents/runtime/support.d.ts

@@ -0,0 +1,19 @@
+import { type AgentHarness, type JsonlSessionRepoApi } from "@earendil-works/pi-agent-core/node";
+import type { SkillsService } from "../../skills";
+import type { AgentSessionMetadata } from "../agent-types";
+export interface WorkspaceSkill {
+    name: string;
+    path: string;
+}
+export declare function interruptHarness(harness: AgentHarness): Promise<void>;
+export declare function createSessionRepo(): JsonlSessionRepoApi;
+export declare function getSkillDirs(workspacePath: string, configuredSkillDirs?: string[]): string[];
+export declare function getRuntimeSkillDirs(workspacePath: string, configuredSkillDirs?: string[], skillsService?: SkillsService): Promise<string[]>;
+export declare function listWorkspaceSkills(workspacePath: string, configuredSkillDirs?: string[], skillsService?: SkillsService): Promise<WorkspaceSkill[]>;
+export declare function getEnvApiKey(provider: string): string | undefined;
+export declare function toAgentSessionMetadata(metadata: {
+    createdAt: string;
+    id: string;
+    path: string;
+}): AgentSessionMetadata;
+//# sourceMappingURL=support.d.ts.map

package/dist/runtime/api/modules/agents/runtime/support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"support.d.ts","sourceRoot":"","sources":["../../../../src/modules/agents/runtime/support.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACzB,MAAM,oCAAoC,CAAC;AAG5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAO3D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAc3E;AAED,wBAAgB,iBAAiB,IAAI,mBAAmB,CAKvD;AAED,wBAAgB,YAAY,CAC1B,aAAa,EAAE,MAAM,EACrB,mBAAmB,CAAC,EAAE,MAAM,EAAE,GAC7B,MAAM,EAAE,CAOV;AAED,wBAAsB,mBAAmB,CACvC,aAAa,EAAE,MAAM,EACrB,mBAAmB,CAAC,EAAE,MAAM,EAAE,EAC9B,aAAa,CAAC,EAAE,aAAa,GAC5B,OAAO,CAAC,MAAM,EAAE,CAAC,CAanB;AAED,wBAAsB,mBAAmB,CACvC,aAAa,EAAE,MAAM,EACrB,mBAAmB,CAAC,EAAE,MAAM,EAAE,EAC9B,aAAa,CAAC,EAAE,aAAa,GAC5B,OAAO,CAAC,cAAc,EAAE,CAAC,CAW3B;AAoED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEjE;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,oBAAoB,CAMvB"}

package/dist/runtime/api/modules/agents/runtime/support.js

@@ -0,0 +1,106 @@
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { JsonlSessionRepo, NodeExecutionEnv } from "@earendil-works/pi-agent-core/node";
+import { SESSIONS_DIR, SKILL_DIR } from "../../../config/const.js";
+export async function interruptHarness(harness) {
+    const interruptibleHarness = harness;
+    if (interruptibleHarness.interrupt) {
+        await interruptibleHarness.interrupt();
+        return;
+    }
+    if (interruptibleHarness.abort) {
+        await interruptibleHarness.abort();
+        return;
+    }
+    throw new Error("Agent runtime does not support interruption");
+}
+export function createSessionRepo() {
+    return new JsonlSessionRepo({
+        fs: new NodeExecutionEnv({ cwd: SESSIONS_DIR }),
+        sessionsRoot: SESSIONS_DIR
+    });
+}
+export function getSkillDirs(workspacePath, configuredSkillDirs) {
+    return Array.from(new Set([
+        join(workspacePath, ".agents", "skills"),
+        join(workspacePath, ".hold-rein", "skills"),
+        SKILL_DIR,
+        ...(configuredSkillDirs ?? [])
+    ]));
+}
+export async function getRuntimeSkillDirs(workspacePath, configuredSkillDirs, skillsService) {
+    const enabledGlobalSkillDirs = await skillsService?.listEnabledSkillDirs();
+    if (!enabledGlobalSkillDirs) {
+        return getSkillDirs(workspacePath, configuredSkillDirs);
+    }
+    return Array.from(new Set([
+        join(workspacePath, ".agents", "skills"),
+        join(workspacePath, ".hold-rein", "skills"),
+        ...enabledGlobalSkillDirs,
+        ...(configuredSkillDirs ?? [])
+    ]));
+}
+export async function listWorkspaceSkills(workspacePath, configuredSkillDirs, skillsService) {
+    const skillDirs = await getRuntimeSkillDirs(workspacePath, configuredSkillDirs, skillsService);
+    const skills = await Promise.all(skillDirs.map((skillDir) => listSkillsInDir(skillDir)));
+    return skills.flat();
+}
+async function listSkillsInDir(skillDir) {
+    let entries;
+    const directSkill = await readSkillPath(skillDir);
+    if (directSkill) {
+        return [directSkill];
+    }
+    try {
+        entries = await readdir(skillDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const skillEntries = entries
+        .filter((entry) => entry.isDirectory())
+        .sort((leftEntry, rightEntry) => leftEntry.name.localeCompare(rightEntry.name));
+    const skills = await Promise.all(skillEntries.map((entry) => readSkill(skillDir, entry.name)));
+    return skills.filter((skill) => skill !== null);
+}
+async function readSkill(skillDir, skillFolderName) {
+    return readSkillPath(join(skillDir, skillFolderName));
+}
+async function readSkillPath(skillPath) {
+    const skillFilePath = join(skillPath, "SKILL.md");
+    try {
+        const content = await readFile(skillFilePath, "utf8");
+        return {
+            name: parseSkillName(content) ?? basename(skillPath),
+            path: skillPath
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseSkillName(content) {
+    const frontmatterMatch = /^---\n(?<frontmatter>[\s\S]*?)\n---/u.exec(content);
+    const frontmatter = frontmatterMatch?.groups?.frontmatter;
+    if (!frontmatter) {
+        return undefined;
+    }
+    for (const line of frontmatter.split("\n")) {
+        const nameMatch = /^name:\s*(?<name>.+?)\s*$/u.exec(line);
+        const rawName = nameMatch?.groups?.name;
+        if (rawName) {
+            return rawName.replace(/^["']|["']$/gu, "");
+        }
+    }
+    return undefined;
+}
+export function getEnvApiKey(provider) {
+    return process.env[`${provider.toUpperCase()}_API_KEY`];
+}
+export function toAgentSessionMetadata(metadata) {
+    return {
+        createdAt: metadata.createdAt,
+        id: metadata.id,
+        path: metadata.path
+    };
+}

package/dist/runtime/api/modules/agents/runtime/token-collection.d.ts

@@ -0,0 +1,28 @@
+import type { AgentHarnessEvent } from "@earendil-works/pi-agent-core";
+import type { NewModelTokenUsageHourlyRow, TaskRow } from "../../../db";
+export interface TaskTokenUsageDelta {
+    inputToken: number;
+    outputToken: number;
+}
+export interface TokenUsageStorageTarget {
+    addModelTokenUsageHourly: (usage: NewModelTokenUsageHourlyRow) => unknown;
+    addTaskTokenUsage: (taskId: string, usage: Pick<TaskRow, "inputToken" | "outputToken">) => unknown;
+}
+export interface TokenCollection {
+    appendHarness: (harness: TokenCollectableHarness) => void;
+    flush: () => void;
+}
+interface TokenCollectableHarness {
+    subscribe: (listener: (event: AgentHarnessEvent, signal?: AbortSignal) => Promise<void> | void) => () => void;
+}
+export interface CreateTokenCollectionOptions {
+    flushIntervalMs?: number;
+    storageTarget?: TokenUsageStorageTarget;
+}
+export declare function createRuntimeTokenCollectionOptions(input: {
+    tokenFlushIntervalMs?: number | undefined;
+    tokenUsageStorageTarget?: TokenUsageStorageTarget | undefined;
+}): CreateTokenCollectionOptions;
+export declare function createTokenCollection(taskId: string, options?: CreateTokenCollectionOptions): TokenCollection;
+export {};
+//# sourceMappingURL=token-collection.d.ts.map

package/dist/runtime/api/modules/agents/runtime/token-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-collection.d.ts","sourceRoot":"","sources":["../../../../src/modules/agents/runtime/token-collection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAExE,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,uBAAuB;IACtC,wBAAwB,EAAE,CAAC,KAAK,EAAE,2BAA2B,KAAK,OAAO,CAAC;IAC1E,iBAAiB,EAAE,CACjB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAAC,KAC/C,OAAO,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAC1D,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,UAAU,uBAAuB;IAC/B,SAAS,EAAE,CACT,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,KAC/E,MAAM,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,4BAA4B;IAC3C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,uBAAuB,CAAC;CACzC;AAID,wBAAgB,mCAAmC,CAAC,KAAK,EAAE;IACzD,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,uBAAuB,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;CAC/D,GAAG,4BAA4B,CAS/B;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,4BAAiC,GACzC,eAAe,CAoIjB"}

package/dist/runtime/api/modules/agents/runtime/token-collection.js

@@ -0,0 +1,131 @@
+const DEFAULT_TOKEN_FLUSH_INTERVAL_MS = 5000;
+export function createRuntimeTokenCollectionOptions(input) {
+    if (!input.tokenUsageStorageTarget)
+        return {};
+    return {
+        ...(input.tokenFlushIntervalMs === undefined
+            ? {}
+            : { flushIntervalMs: input.tokenFlushIntervalMs }),
+        storageTarget: input.tokenUsageStorageTarget
+    };
+}
+export function createTokenCollection(taskId, options = {}) {
+    let pendingInputToken = 0;
+    let pendingOutputToken = 0;
+    let flushTimer;
+    const flushIntervalMs = options.flushIntervalMs ?? DEFAULT_TOKEN_FLUSH_INTERVAL_MS;
+    const subscriptions = new Map();
+    const pendingModelUsages = new Map();
+    const scheduleFlush = () => {
+        if (options.storageTarget === undefined || flushTimer !== undefined)
+            return;
+        flushTimer = setTimeout(() => {
+            flushTimer = undefined;
+            flush();
+        }, flushIntervalMs);
+    };
+    const record = (usage) => {
+        pendingInputToken += usage.inputToken;
+        pendingOutputToken += usage.outputToken;
+        const hour = toUsageHour(usage.hour);
+        const key = `${usage.provider}\0${usage.modelName}\0${hour}`;
+        const existingUsage = pendingModelUsages.get(key);
+        pendingModelUsages.set(key, {
+            hour,
+            inputToken: (existingUsage?.inputToken ?? 0) + usage.inputToken,
+            modelName: usage.modelName,
+            outputToken: (existingUsage?.outputToken ?? 0) + usage.outputToken,
+            provider: usage.provider
+        });
+        scheduleFlush();
+    };
+    const requeueModelUsage = (usage) => {
+        const key = `${usage.provider}\0${usage.modelName}\0${usage.hour}`;
+        const existingUsage = pendingModelUsages.get(key);
+        pendingModelUsages.set(key, {
+            ...usage,
+            inputToken: (existingUsage?.inputToken ?? 0) + (usage.inputToken ?? 0),
+            outputToken: (existingUsage?.outputToken ?? 0) + (usage.outputToken ?? 0)
+        });
+    };
+    function flush() {
+        if (flushTimer !== undefined) {
+            clearTimeout(flushTimer);
+            flushTimer = undefined;
+        }
+        const storageTarget = options.storageTarget;
+        if (storageTarget === undefined)
+            return;
+        const taskUsage = {
+            inputToken: pendingInputToken,
+            outputToken: pendingOutputToken
+        };
+        const modelUsages = [...pendingModelUsages.values()];
+        pendingInputToken = 0;
+        pendingOutputToken = 0;
+        pendingModelUsages.clear();
+        if (taskUsage.inputToken > 0 || taskUsage.outputToken > 0) {
+            try {
+                storageTarget.addTaskTokenUsage(taskId, taskUsage);
+            }
+            catch {
+                pendingInputToken += taskUsage.inputToken;
+                pendingOutputToken += taskUsage.outputToken;
+            }
+        }
+        for (const modelUsage of modelUsages) {
+            try {
+                storageTarget.addModelTokenUsageHourly(modelUsage);
+            }
+            catch {
+                requeueModelUsage(modelUsage);
+            }
+        }
+        if (pendingInputToken > 0 ||
+            pendingOutputToken > 0 ||
+            pendingModelUsages.size > 0) {
+            scheduleFlush();
+        }
+    }
+    return {
+        appendHarness: (harness) => {
+            if (subscriptions.has(harness))
+                return;
+            const unsubscribe = harness.subscribe((event) => {
+                if (!subscriptions.has(harness))
+                    return;
+                if (event.type === "message_end") {
+                    if (event.message.role !== "assistant") {
+                        return;
+                    }
+                    const usage = event.message.usage;
+                    const usageDelta = {
+                        inputToken: usage?.input ?? 0,
+                        outputToken: usage?.output ?? 0
+                    };
+                    if (usageDelta.inputToken > 0 || usageDelta.outputToken > 0) {
+                        record({
+                            ...usageDelta,
+                            hour: new Date(event.message.timestamp).toISOString(),
+                            modelName: event.message.model,
+                            provider: event.message.provider
+                        });
+                    }
+                    return;
+                }
+                if (event.type === "agent_end") {
+                    subscriptions.get(harness)?.();
+                    subscriptions.delete(harness);
+                    flush();
+                }
+            });
+            subscriptions.set(harness, unsubscribe);
+        },
+        flush
+    };
+}
+function toUsageHour(value) {
+    const date = new Date(value);
+    date.setUTCMinutes(0, 0, 0);
+    return date.toISOString();
+}

package/dist/runtime/api/modules/agents/runtime/token-usage-sync.d.ts

@@ -0,0 +1,15 @@
+import type { TaskTokenUsageDelta } from "./token-collection";
+export interface TokenUsageSyncTarget {
+    addTaskTokenUsage: (taskId: string, usage: TaskTokenUsageDelta) => unknown;
+}
+export interface TokenUsageSync {
+    flush: () => void;
+    record: (usage: TaskTokenUsageDelta) => void;
+}
+export interface CreateTokenUsageSyncOptions {
+    flushIntervalMs?: number;
+    syncTarget: TokenUsageSyncTarget;
+    taskId: string;
+}
+export declare function createTokenUsageSync(options: CreateTokenUsageSyncOptions): TokenUsageSync;
+//# sourceMappingURL=token-usage-sync.d.ts.map

package/dist/runtime/api/modules/agents/runtime/token-usage-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-usage-sync.d.ts","sourceRoot":"","sources":["../../../../src/modules/agents/runtime/token-usage-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,MAAM,WAAW,oBAAoB;IACnC,iBAAiB,EAAE,CACjB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,mBAAmB,KACvB,OAAO,CAAC;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,MAAM,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,CAAC;CAC9C;AAED,MAAM,WAAW,2BAA2B;IAC1C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,oBAAoB,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;CAChB;AAID,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,2BAA2B,GACnC,cAAc,CAkDhB"}

package/dist/runtime/api/modules/agents/runtime/token-usage-sync.js

@@ -0,0 +1,46 @@
+const DEFAULT_TOKEN_FLUSH_INTERVAL_MS = 5000;
+export function createTokenUsageSync(options) {
+    let pendingInputToken = 0;
+    let pendingOutputToken = 0;
+    let flushTimer;
+    const flushIntervalMs = options.flushIntervalMs ?? DEFAULT_TOKEN_FLUSH_INTERVAL_MS;
+    const scheduleFlush = () => {
+        if (flushTimer !== undefined)
+            return;
+        flushTimer = setTimeout(() => {
+            flushTimer = undefined;
+            flush();
+        }, flushIntervalMs);
+    };
+    const flush = () => {
+        if (flushTimer !== undefined) {
+            clearTimeout(flushTimer);
+            flushTimer = undefined;
+        }
+        if (pendingInputToken === 0 && pendingOutputToken === 0) {
+            return;
+        }
+        const usage = {
+            inputToken: pendingInputToken,
+            outputToken: pendingOutputToken
+        };
+        pendingInputToken = 0;
+        pendingOutputToken = 0;
+        try {
+            options.syncTarget.addTaskTokenUsage(options.taskId, usage);
+        }
+        catch {
+            pendingInputToken += usage.inputToken;
+            pendingOutputToken += usage.outputToken;
+            scheduleFlush();
+        }
+    };
+    return {
+        flush,
+        record: (usage) => {
+            pendingInputToken += usage.inputToken;
+            pendingOutputToken += usage.outputToken;
+            scheduleFlush();
+        }
+    };
+}