@botbotgo/agent-harness 0.0.309 → 0.0.311

package/dist/flow/flow-graph-upstream.js

@@ -0,0 +1,498 @@
+import { createUpstreamTimelineReducer } from "../projections/upstream-events.js";
+import { asObject, buildAttemptKey, deriveAgentName, deriveNodeKindFromProjection, deriveStatusFromProjection, extractUpstreamEventEnvelope, normalizeAttemptLabel, normalizeToolIdentity, readRequestId, readSessionId, slugify, titleCase, } from "./flow-graph-normalization.js";
+import { buildSurfaceId, resolveSurfaceAction, stripStepPrefix, } from "../runtime/harness/run/surface-semantics.js";
+function buildSurfaceStepLabel(surfaceItem) {
+    const kind = surfaceItem.kind;
+    const name = typeof surfaceItem.name === "string" && surfaceItem.name.trim().length > 0
+        ? surfaceItem.name.trim()
+        : typeof surfaceItem.id === "string"
+            ? surfaceItem.id
+            : "";
+    const status = surfaceItem.status;
+    if (!kind || !name || !status || (status !== "started" && status !== "completed" && status !== "failed")) {
+        return null;
+    }
+    if (kind === "llm") {
+        return status === "started" ? `Calling LLM ${name}` : `Completed LLM ${name}`;
+    }
+    if (kind === "tool") {
+        if (status === "failed") {
+            return `Tool ${name} failed`;
+        }
+        return status === "started" ? `Calling tool ${name}` : `Completed tool ${name}`;
+    }
+    if (kind === "skill") {
+        return status === "started" ? `Calling skill ${name}` : `Completed skill ${name}`;
+    }
+    if (kind === "memory") {
+        return status === "started" ? `Accessing memory ${name}` : `Completed memory ${name}`;
+    }
+    return null;
+}
+function createDelegationNodeFromSurfaceItem(surfaceItem, fallbackAgentId, fallbackAgentName, sourceEventId, ordinal) {
+    if (surfaceItem.kind !== "agent") {
+        return null;
+    }
+    const toAgentId = typeof surfaceItem.agentId === "string" && surfaceItem.agentId.trim().length > 0
+        ? surfaceItem.agentId.trim()
+        : fallbackAgentId;
+    const toAgentName = deriveAgentName(toAgentId, typeof surfaceItem.agentName === "string" ? surfaceItem.agentName : undefined);
+    const fromAgentId = typeof surfaceItem.ownerAgentId === "string" && surfaceItem.ownerAgentId.trim().length > 0
+        ? surfaceItem.ownerAgentId.trim()
+        : fallbackAgentId;
+    const fromAgentName = deriveAgentName(fromAgentId, typeof surfaceItem.ownerAgentName === "string" ? surfaceItem.ownerAgentName : fallbackAgentName);
+    return {
+        id: `delegate:${slugify(fromAgentId)}:${slugify(toAgentId)}:${ordinal}`,
+        layer: "execution",
+        kind: "agent",
+        label: `Delegate to ${titleCase(typeof surfaceItem.name === "string" ? surfaceItem.name : toAgentId)}`,
+        status: surfaceItem.status === "failed" ? "failed" : surfaceItem.status === "started" ? "started" : "completed",
+        sessionId: "",
+        requestId: "",
+        agentId: toAgentId,
+        agentName: toAgentName,
+        sourceEventIds: [sourceEventId],
+        detail: {
+            fromAgentId,
+            fromAgentName,
+            toAgentId,
+            toAgentName,
+            ...(typeof surfaceItem.action === "string" ? { action: surfaceItem.action } : {}),
+        },
+    };
+}
+function extractDelegatedAgentId(event) {
+    const typed = asObject(event);
+    if (!typed) {
+        return null;
+    }
+    const eventName = typeof typed.event === "string" ? typed.event : "";
+    const toolName = typeof typed.name === "string" ? typed.name : "";
+    if (toolName !== "task" || (eventName !== "on_tool_start" && !(eventName === "on_chain_start" && typed.run_type === "tool"))) {
+        return null;
+    }
+    const data = asObject(typed.data);
+    const input = asObject(data?.input);
+    const nestedInput = typeof input?.input === "string"
+        ? asObject(JSON.parse(input.input))
+        : asObject(input?.input);
+    const subagentType = typeof input?.subagent_type === "string"
+        ? input.subagent_type
+        : typeof input?.subagentType === "string"
+            ? input.subagentType
+            : typeof nestedInput?.subagent_type === "string"
+                ? nestedInput.subagent_type
+                : typeof nestedInput?.subagentType === "string"
+                    ? nestedInput.subagentType
+                    : null;
+    return subagentType && subagentType.trim().length > 0 ? subagentType.trim() : null;
+}
+export function convertUpstreamEventsWithAgents(upstreamEvents, initialAgentId) {
+    const reducer = createUpstreamTimelineReducer();
+    const projections = [];
+    const delegationNodes = [];
+    let currentAgentId = initialAgentId;
+    let currentAgentName = deriveAgentName(initialAgentId);
+    let ordinal = 0;
+    upstreamEvents.forEach((event, index) => {
+        const sourceEventId = `upstream:${index + 1}`;
+        const envelope = extractUpstreamEventEnvelope(event);
+        if (envelope.agentId && envelope.agentId !== currentAgentId) {
+            currentAgentId = envelope.agentId;
+            currentAgentName = deriveAgentName(currentAgentId, envelope.agentName);
+        }
+        else if (envelope.agentName) {
+            currentAgentName = deriveAgentName(currentAgentId, envelope.agentName);
+        }
+        const emitted = reducer.consume(envelope.event);
+        for (const projection of emitted) {
+            if (envelope.surfaceItem && projection.type === "step") {
+                continue;
+            }
+            projections.push({
+                projection,
+                agentId: currentAgentId,
+                agentName: currentAgentName,
+                sourceEventId,
+            });
+        }
+        if (envelope.surfaceItem) {
+            const delegationNode = createDelegationNodeFromSurfaceItem(envelope.surfaceItem, currentAgentId, currentAgentName, sourceEventId, ordinal + 1);
+            if (delegationNode) {
+                ordinal += 1;
+                delegationNodes.push(delegationNode);
+            }
+            else {
+                const step = buildSurfaceStepLabel(envelope.surfaceItem);
+                if (step) {
+                    projections.push({
+                        projection: {
+                            type: "step",
+                            key: `surface:${index + 1}:${envelope.surfaceItem.id ?? step}`,
+                            category: envelope.surfaceItem.kind,
+                            status: envelope.surfaceItem.status,
+                            step,
+                        },
+                        agentId: currentAgentId,
+                        agentName: currentAgentName,
+                        sourceEventId,
+                    });
+                }
+            }
+        }
+        if (envelope.surfaceItem) {
+            return;
+        }
+        const delegatedAgentId = extractDelegatedAgentId(envelope.event);
+        if (!delegatedAgentId || delegatedAgentId === currentAgentId) {
+            return;
+        }
+        const delegatedAgentName = deriveAgentName(delegatedAgentId);
+        ordinal += 1;
+        delegationNodes.push({
+            id: `delegate:${slugify(initialAgentId)}:${slugify(delegatedAgentId)}:${ordinal}`,
+            layer: "execution",
+            kind: "agent",
+            label: `Delegate to ${titleCase(delegatedAgentId)}`,
+            status: "completed",
+            sessionId: "",
+            requestId: "",
+            agentId: delegatedAgentId,
+            agentName: delegatedAgentName,
+            sourceEventIds: [sourceEventId],
+            detail: {
+                fromAgentId: currentAgentId,
+                fromAgentName: currentAgentName,
+                toAgentId: delegatedAgentId,
+                toAgentName: delegatedAgentName,
+            },
+        });
+        currentAgentId = delegatedAgentId;
+        currentAgentName = delegatedAgentName;
+    });
+    return { projections, delegationNodes };
+}
+function selectInitialGroup(groups) {
+    return groups.find((group) => group.kind === "segment") ?? groups[0] ?? null;
+}
+export function buildAttempts(projectionRecords, delegationNodes, runtimeGroups, sessionId, requestId) {
+    const nodes = [];
+    const edges = [];
+    const groups = [];
+    const attempts = [];
+    const activeAttemptsByKey = new Map();
+    const toolAttemptsByName = new Map();
+    const attemptSetGroups = new Map();
+    let currentGroup = selectInitialGroup(runtimeGroups);
+    let awaitingResumeAfterApproval = false;
+    let previousAttempt = null;
+    let ordinal = 0;
+    let pendingDelegationNode = null;
+    let delegationIndex = 0;
+    const segmentGroups = runtimeGroups.filter((group) => group.kind === "segment");
+    let nextSegmentIndex = currentGroup && currentGroup.kind === "segment"
+        ? Math.max(segmentGroups.findIndex((group) => group.id === currentGroup?.id), 0)
+        : 0;
+    function promoteToNextSegment() {
+        if (nextSegmentIndex + 1 < segmentGroups.length) {
+            nextSegmentIndex += 1;
+            currentGroup = segmentGroups[nextSegmentIndex] ?? currentGroup;
+        }
+    }
+    function createAttempt(kind, label, projection, agentId, agentName) {
+        ordinal += 1;
+        const attempt = {
+            id: `attempt:${requestId}:${slugify(kind)}:${slugify(label)}:${ordinal}`,
+            kind,
+            label,
+            status: deriveStatusFromProjection(projection),
+            agentId,
+            agentName,
+            groupId: currentGroup?.id,
+            sourceEventIds: [],
+            attemptKey: buildAttemptKey(kind, label, currentGroup?.id),
+            detail: {},
+            projectionKeys: [],
+            ...(projection.type === "tool-result" ? { toolName: projection.toolName } : {}),
+        };
+        attempts.push(attempt);
+        if (kind === "tool" || (projection.type === "tool-result" && projection.toolName)) {
+            const toolName = projection.type === "tool-result"
+                ? normalizeToolIdentity(projection.toolName)
+                : normalizeToolIdentity(label.replace(/^Calling tool\s+/i, ""));
+            const existing = toolAttemptsByName.get(toolName) ?? [];
+            if (existing.length > 0) {
+                const prior = existing[existing.length - 1];
+                const edgeKind = prior.status === "failed" ? "retry" : "fallback";
+                edges.push({
+                    id: `edge:${prior.id}->${attempt.id}`,
+                    from: prior.id,
+                    to: attempt.id,
+                    kind: edgeKind,
+                    sourceEventIds: [],
+                    confidence: 0.55,
+                });
+            }
+            existing.push(attempt);
+            toolAttemptsByName.set(toolName, existing);
+        }
+        return attempt;
+    }
+    for (const record of projectionRecords) {
+        const projection = record.projection;
+        if (!pendingDelegationNode
+            && delegationIndex < delegationNodes.length
+            && delegationNodes[delegationIndex]?.agentId === record.agentId
+            && (!previousAttempt || previousAttempt.agentId !== record.agentId)) {
+            const sourceNode = delegationNodes[delegationIndex];
+            delegationIndex += 1;
+            pendingDelegationNode = {
+                ...sourceNode,
+                sessionId,
+                requestId,
+                groupId: currentGroup?.id,
+            };
+            nodes.push(pendingDelegationNode);
+            if (previousAttempt) {
+                edges.push({
+                    id: `edge:${previousAttempt.id}->${pendingDelegationNode.id}`,
+                    from: previousAttempt.id,
+                    to: pendingDelegationNode.id,
+                    kind: "spawn",
+                    label: "delegate",
+                    sourceEventIds: [...pendingDelegationNode.sourceEventIds],
+                    confidence: 0.9,
+                });
+            }
+            else if (currentGroup?.anchorNodeId) {
+                edges.push({
+                    id: `edge:${currentGroup.anchorNodeId}->${pendingDelegationNode.id}`,
+                    from: currentGroup.anchorNodeId,
+                    to: pendingDelegationNode.id,
+                    kind: "spawn",
+                    label: "delegate",
+                    sourceEventIds: [...pendingDelegationNode.sourceEventIds],
+                    confidence: 0.9,
+                });
+            }
+        }
+        if (previousAttempt
+            && previousAttempt.agentId
+            && record.agentId !== previousAttempt.agentId
+            && delegationIndex < delegationNodes.length) {
+            const sourceNode = delegationNodes[delegationIndex];
+            delegationIndex += 1;
+            pendingDelegationNode = {
+                ...sourceNode,
+                sessionId,
+                requestId,
+                groupId: currentGroup?.id,
+            };
+            nodes.push(pendingDelegationNode);
+            edges.push({
+                id: `edge:${previousAttempt.id}->${pendingDelegationNode.id}`,
+                from: previousAttempt.id,
+                to: pendingDelegationNode.id,
+                kind: "spawn",
+                label: "delegate",
+                sourceEventIds: [...pendingDelegationNode.sourceEventIds],
+                confidence: 0.9,
+            });
+        }
+        if (projection.type === "thinking") {
+            ordinal += 1;
+            const detailNode = {
+                id: `detail:${requestId}:thinking:${ordinal}`,
+                layer: "detail",
+                kind: "thinking",
+                label: "Model reasoning",
+                status: "completed",
+                sessionId,
+                requestId,
+                groupId: currentGroup?.id,
+                sourceEventIds: [],
+                detail: { text: projection.text },
+            };
+            nodes.push(detailNode);
+            if (previousAttempt) {
+                edges.push({
+                    id: `edge:${previousAttempt.id}->${detailNode.id}`,
+                    from: previousAttempt.id,
+                    to: detailNode.id,
+                    kind: "result",
+                    sourceEventIds: [],
+                    confidence: 0.6,
+                });
+            }
+            continue;
+        }
+        const kind = deriveNodeKindFromProjection(projection);
+        const label = normalizeAttemptLabel(kind, projection);
+        if (kind === "approval") {
+            const activeApproval = runtimeGroups.find((group) => group.kind === "approval-window");
+            if (activeApproval) {
+                currentGroup = activeApproval;
+            }
+            awaitingResumeAfterApproval = true;
+        }
+        else if (awaitingResumeAfterApproval && currentGroup?.kind === "approval-window") {
+            promoteToNextSegment();
+            awaitingResumeAfterApproval = false;
+        }
+        const attemptKey = buildAttemptKey(kind, label, currentGroup?.id);
+        let attempt;
+        if (projection.type === "step" && projection.status === "started") {
+            attempt = createAttempt(kind, label, projection, record.agentId, record.agentName);
+            activeAttemptsByKey.set(attemptKey, attempt);
+        }
+        else if (projection.type === "tool-result") {
+            const toolName = normalizeToolIdentity(projection.toolName);
+            const existing = toolAttemptsByName.get(toolName) ?? [];
+            attempt = [...existing].reverse().find((candidate) => candidate.groupId === currentGroup?.id) ?? existing[existing.length - 1];
+            if (!attempt) {
+                attempt = createAttempt("tool", `Calling tool ${titleCase(toolName)}`, projection, record.agentId, record.agentName);
+            }
+        }
+        else {
+            attempt = activeAttemptsByKey.get(attemptKey);
+            if (!attempt) {
+                attempt = createAttempt(kind, label, projection, record.agentId, record.agentName);
+            }
+        }
+        attempt.agentId = attempt.agentId ?? record.agentId;
+        attempt.agentName = attempt.agentName ?? record.agentName;
+        attempt.projectionKeys.push(projection.key);
+        attempt.sourceEventIds.push(record.sourceEventId);
+        if (projection.type === "step") {
+            attempt.status = deriveStatusFromProjection(projection);
+            attempt.detail.category = projection.category;
+            attempt.detail.step = projection.step;
+        }
+        else if (projection.type === "tool-result") {
+            attempt.status = projection.isError ? "failed" : "completed";
+            attempt.toolName = projection.toolName;
+            attempt.detail.toolName = projection.toolName;
+            attempt.detail.result = projection.output;
+            attempt.detail.resultIsError = projection.isError === true;
+            if (projection.isError) {
+                activeAttemptsByKey.delete(buildAttemptKey("tool", attempt.label, attempt.groupId));
+            }
+        }
+        if (!attemptSetGroups.has(`${kind}:${currentGroup?.id ?? "ungrouped"}`)) {
+            attemptSetGroups.set(`${kind}:${currentGroup?.id ?? "ungrouped"}`, {
+                id: `group:${requestId}:attempt-set:${slugify(kind)}:${attemptSetGroups.size + 1}`,
+                kind: "attempt-set",
+                label: `${titleCase(kind)} attempts`,
+                nodeIds: [],
+            });
+        }
+        const attemptGroup = attemptSetGroups.get(`${kind}:${currentGroup?.id ?? "ungrouped"}`);
+        if (!attemptGroup.nodeIds.includes(attempt.id)) {
+            attemptGroup.nodeIds.push(attempt.id);
+        }
+        if (pendingDelegationNode && pendingDelegationNode.id !== attempt.id) {
+            edges.push({
+                id: `edge:${pendingDelegationNode.id}->${attempt.id}`,
+                from: pendingDelegationNode.id,
+                to: attempt.id,
+                kind: "spawn",
+                sourceEventIds: [...pendingDelegationNode.sourceEventIds, ...attempt.sourceEventIds],
+                confidence: 0.9,
+            });
+            pendingDelegationNode = null;
+        }
+        else if (previousAttempt && previousAttempt.id !== attempt.id) {
+            edges.push({
+                id: `edge:${previousAttempt.id}->${attempt.id}`,
+                from: previousAttempt.id,
+                to: attempt.id,
+                kind: kind === "approval" ? "approval" : "sequence",
+                sourceEventIds: [],
+                confidence: 0.7,
+            });
+        }
+        else if (!previousAttempt && currentGroup?.anchorNodeId) {
+            edges.push({
+                id: `edge:${currentGroup.anchorNodeId}->${attempt.id}`,
+                from: currentGroup.anchorNodeId,
+                to: attempt.id,
+                kind: "contains",
+                sourceEventIds: [],
+                confidence: 0.8,
+            });
+        }
+        previousAttempt = attempt;
+        if (projection.type === "step" && projection.status !== "started") {
+            activeAttemptsByKey.delete(attemptKey);
+        }
+    }
+    for (const attempt of attempts) {
+        nodes.push({
+            id: attempt.id,
+            layer: "attempt",
+            kind: attempt.kind,
+            label: attempt.label,
+            status: attempt.status,
+            sessionId,
+            requestId,
+            agentId: attempt.agentId,
+            agentName: attempt.agentName,
+            groupId: attempt.groupId,
+            sequenceStart: attempt.sequenceStart,
+            sequenceEnd: attempt.sequenceEnd,
+            startedAt: attempt.startedAt,
+            endedAt: attempt.endedAt,
+            sourceEventIds: [...new Set(attempt.sourceEventIds)],
+            detail: { ...attempt.detail, projectionKeys: attempt.projectionKeys },
+        });
+    }
+    groups.push(...attemptSetGroups.values());
+    return { nodes, edges, groups };
+}
+export function resolveContext(input, runtimeTimeline, projections) {
+    const timelineHead = runtimeTimeline[0];
+    const inputSessionId = readSessionId(input);
+    const inputRequestId = readRequestId(input);
+    if (inputSessionId && inputRequestId) {
+        return { sessionId: inputSessionId, requestId: inputRequestId };
+    }
+    if (timelineHead) {
+        return {
+            sessionId: inputSessionId ?? timelineHead.sessionId,
+            requestId: inputRequestId ?? timelineHead.requestId,
+        };
+    }
+    const firstProjection = projections[0];
+    if (!inputSessionId || !inputRequestId) {
+        throw new Error(`buildFlowGraph requires sessionId and requestId when runtime timeline data is absent${firstProjection ? "" : " or empty"}.`);
+    }
+    return { sessionId: inputSessionId, requestId: inputRequestId };
+}
+export function buildRuntimeSurface(nodes) {
+    return nodes
+        .filter((node) => node.layer !== "detail"
+        && (node.kind === "agent" || node.kind === "llm" || node.kind === "memory" || node.kind === "skill" || node.kind === "tool"))
+        .map((node) => ({
+        kind: node.kind,
+        id: buildSurfaceId(node.kind, node.kind === "agent" ? (node.agentId ?? node.agentName ?? "agent") : node.label),
+        name: node.kind === "agent"
+            ? (node.agentName ?? node.agentId ?? "Agent")
+            : stripStepPrefix(node.label),
+        action: resolveSurfaceAction({
+            kind: node.kind,
+            step: node.label,
+            event: node.detail,
+        }),
+        status: node.status === "resolved" ? "completed" : node.status,
+        agentId: node.agentId,
+        agentName: node.agentName,
+        ownerAgentId: node.kind === "agent"
+            ? (typeof node.detail.fromAgentId === "string" ? node.detail.fromAgentId : node.agentId)
+            : node.agentId,
+        ownerAgentName: node.kind === "agent"
+            ? (typeof node.detail.fromAgentName === "string" ? node.detail.fromAgentName : node.agentName)
+            : node.agentName,
+        sourceEventId: node.sourceEventIds[0],
+        detail: { ...node.detail },
+    }));
+}

package/dist/flow/types.d.ts

@@ -1,5 +1,5 @@
 import type { HarnessEvent, RuntimeTimelineItem } from "../contracts/types.js";
-import type { UpstreamTimelineProjection } from "../upstream-events.js";
+import type { UpstreamTimelineProjection } from "../projections/upstream-events.js";
 export type BuildFlowGraphRuntimeEvent = HarnessEvent | {
     eventId: string;
     eventType: string;

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRequest, createAgentHarness, createAcpServer, createAcpStdioClient, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportFlow, exportSequence, exportRequestPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getOperatorOverview, getRequestPlanState, getRequest, getHealth, listMemories, listRequestTraceItems, getSession, listAgentSkills, listRequestArtifacts, listApprovals, listRequests, listRequestEvents, listSessionSummaries, listSessions, memorize, normalizeUserChatInput, recordArtifact, request, recall, removeMemory, resolveApproval, serveA2aHttp, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveRuntimeMcpOverStreamableHttp, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
 export { AcpHarnessClient, InProcessHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient, createAgentHarnessClient, createInProcessHarnessClient, } from "./client.js";
 export { createKnowledgeModule, readKnowledgeRuntimeConfig } from "./knowledge/index.js";
-export { readProceduralMemoryRuntimeConfig } from "./procedural/index.js";
+export { readProceduralMemoryRuntimeConfig } from "./knowledge/procedural/index.js";
 export type { AcpApproval, AcpHttpClient, AcpHttpClientOptions, AcpArtifact, AcpEventNotification, AcpNotification, AcpJsonRpcError, AcpJsonRpcRequest, AcpJsonRpcResponse, AcpJsonRpcSuccess, AcpRequestRecord, AcpRequestParams, AcpServerCapabilities, AcpSessionRecord, AcpStreamNotification, AcpStdioClient, AcpStdioClientOptions, } from "./acp.js";
 export type { Approval, CreateAgentHarnessOptions, ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, NormalizeUserChatInputOptions, OperatorOverview, RecordArtifactInput, PublicRequestListeners, RequestData, RequestArtifactListing, RequestEvent, RequestEventType, RequestSnapshot, RequestPlanState, RequestPackage, RequestPackageInput, RequestFlowGraphInput, RequestResult, RequestTraceItem, RecallInput, RecallResult, RemoveMemoryInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, SessionListSummary, RuntimeSessionPackage, RuntimeSessionPackageInput, UpdateMemoryInput, UserChatInput, UserChatMessage, } from "./api.js";
 export type { AcpHarnessTransport, HarnessClient, HarnessClientApprovalFilter, HarnessClientRequestFilter, HarnessClientRequestOptions, HarnessClientRequestResult, HarnessClientRequestStartOptions, } from "./client.js";
 export type { KnowledgeListInput, KnowledgeMemorizeInput, KnowledgeModule, KnowledgeModuleDependencies, KnowledgeRecallInput, KnowledgeRuntimeConfig, KnowledgeRuntimeContext, } from "./knowledge/index.js";
-export type { ProceduralMemoryBackgroundConfig, ProceduralMemoryFormationConfig, ProceduralMemoryMaintenanceConfig, ProceduralMemoryMaintenanceIdleConfig, ProceduralMemoryMaintenanceScheduleConfig, ProceduralMemoryProviderConfig, ProceduralMemoryRetrievalConfig, ProceduralMemoryRuntimeConfig, } from "./procedural/index.js";
+export type { ProceduralMemoryBackgroundConfig, ProceduralMemoryFormationConfig, ProceduralMemoryMaintenanceConfig, ProceduralMemoryMaintenanceIdleConfig, ProceduralMemoryMaintenanceScheduleConfig, ProceduralMemoryProviderConfig, ProceduralMemoryRetrievalConfig, ProceduralMemoryRuntimeConfig, } from "./knowledge/procedural/index.js";
 export type { A2aAgentCard, A2aHttpServer, A2aHttpServerOptions, A2aTask, A2aTaskState, AcpHttpServer, AcpHttpServerOptions, AcpStdioServer, AcpStdioServerOptions, AgUiEvent, AgUiHttpServer, AgUiHttpServerOptions, AgUiRequestAgentInput, } from "./api.js";
 export type { RuntimeMcpServerOptions, ToolMcpServerOptions } from "./mcp.js";
 export { tool } from "./tools.js";
-export type { UpstreamTimelineProjection, UpstreamTimelineReducer } from "./upstream-events.js";
+export type { UpstreamTimelineProjection, UpstreamTimelineReducer } from "./projections/upstream-events.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRequest, createAgentHarness, createAcpServer, createAcpStdioClient, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportFlow, exportSequence, exportRequestPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getOperatorOverview, getRequestPlanState, getRequest, getHealth, listMemories, listRequestTraceItems, getSession, listAgentSkills, listRequestArtifacts, listApprovals, listRequests, listRequestEvents, listSessionSummaries, listSessions, memorize, normalizeUserChatInput, recordArtifact, request, recall, removeMemory, resolveApproval, serveA2aHttp, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveRuntimeMcpOverStreamableHttp, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
 export { AcpHarnessClient, InProcessHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient, createAgentHarnessClient, createInProcessHarnessClient, } from "./client.js";
 export { createKnowledgeModule, readKnowledgeRuntimeConfig } from "./knowledge/index.js";
-export { readProceduralMemoryRuntimeConfig } from "./procedural/index.js";
+export { readProceduralMemoryRuntimeConfig } from "./knowledge/procedural/index.js";
 export { tool } from "./tools.js";

package/dist/init-project.d.ts

@@ -1,12 +1 @@
-export type InitTemplate = "deep-research" | "single-agent";
-export type InitProjectOptions = {
-    template?: InitTemplate;
-    provider?: string;
-    model?: string;
-    withWebSearch?: boolean;
-};
-export type InitProjectResult = {
-    projectRoot: string;
-    projectSlug: string;
-};
-export declare function initProject(projectRoot: string, projectName: string, options?: InitProjectOptions): Promise<InitProjectResult>;
+export * from "./scaffold/init-project.js";