@abot-ai/runtime 1.0.0

package/dist/src/runtime/steps/planner-decision/format.d.ts

@@ -0,0 +1,10 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import type { WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
+import { type PlannerChildRoleId, type PlannerDecisionPlanContext } from "./contracts.js";
+export declare function createPlannerDecisionFormat(options?: Readonly<{
+    availableChildRoleIds?: readonly PlannerChildRoleId[];
+    availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
+    inheritedWorkingDirectory?: string;
+    planContext?: PlannerDecisionPlanContext;
+}>): ModelGatewayJsonSchemaFormat;
+export declare function normalizeAvailableChildRoleIds(values: readonly PlannerChildRoleId[]): readonly PlannerChildRoleId[];

package/dist/src/runtime/steps/planner-decision/format.js

@@ -0,0 +1,251 @@
+import { createStructuredDecisionEnvelopeSchema, structuredDecisionVariantSchemaPath, } from "../../model/structured-decision-envelope.js";
+import { normalizeRoleCallWorkingDirectory, ROLE_CALL_PLAN_ITEM_TITLE_MAX_LENGTH, ROLE_CALL_WORKING_DIRECTORY_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
+import { createWorkerCapabilityScopeDecisionContract } from "../worker-capability-scope-decision.js";
+import { isPlannerChildRoleId, PLANNER_CHILD_ROLE_IDS, PLANNER_OBJECTIVE_MAX_LENGTH, PLANNER_RESULT_MAX_LENGTH, } from "./contracts.js";
+import { normalizePlannerDecisionPlanContext, plannerPlanAllowsInvocation, } from "./plan.js";
+export function createPlannerDecisionFormat(options = {}) {
+    const availableChildRoleIds = normalizeAvailableChildRoleIds(options.availableChildRoleIds ?? PLANNER_CHILD_ROLE_IDS);
+    const availableWorkerCapabilityCatalog = options.availableWorkerCapabilityCatalog ?? [];
+    const workerCapabilityScopeContract = createWorkerCapabilityScopeDecisionContract(availableWorkerCapabilityCatalog);
+    const planContext = options.planContext
+        ? normalizePlannerDecisionPlanContext(options.planContext)
+        : undefined;
+    if (options.inheritedWorkingDirectory !== undefined &&
+        normalizeRoleCallWorkingDirectory(options.inheritedWorkingDirectory) !==
+            options.inheritedWorkingDirectory) {
+        throw new Error("planner_inherited_working_directory_invalid");
+    }
+    const workerAvailable = availableChildRoleIds.includes("worker");
+    const workingDirectoryRequired = options.inheritedWorkingDirectory === undefined;
+    const availableNonWorkerRoleIds = availableChildRoleIds.filter((roleId) => roleId !== "worker");
+    const canInvoke = (workerAvailable || availableNonWorkerRoleIds.length > 0) &&
+        plannerPlanAllowsInvocation(planContext);
+    const selectingPlan = planContext?.mode === "select";
+    const invokeVariantDefinitions = canInvoke
+        ? [
+            ...(workerAvailable
+                ? [
+                    Object.freeze({
+                        worker: true,
+                        schema: invokeRoleSchema({
+                            availableChildRoleIds: ["worker"],
+                            workingDirectoryRequired,
+                            ...(workerCapabilityScopeContract.schema
+                                ? {
+                                    workerCapabilityScopeSchema: workerCapabilityScopeContract.schema,
+                                }
+                                : {}),
+                            planContext,
+                        }),
+                    }),
+                ]
+                : []),
+            ...(availableNonWorkerRoleIds.length > 0
+                ? [
+                    Object.freeze({
+                        worker: false,
+                        schema: invokeRoleSchema({
+                            availableChildRoleIds: availableNonWorkerRoleIds,
+                            planContext,
+                        }),
+                    }),
+                ]
+                : []),
+        ]
+        : [];
+    const variants = [
+        ...(!selectingPlan
+            ? [
+                exactObject({
+                    action: literal("return_result"),
+                    result: boundedText(PLANNER_RESULT_MAX_LENGTH),
+                }),
+            ]
+            : []),
+        exactObject({
+            action: literal("return_failure"),
+            reason: boundedText(PLANNER_RESULT_MAX_LENGTH),
+        }),
+        ...invokeVariantDefinitions.map(({ schema }) => schema),
+    ];
+    const failureVariantIndex = !selectingPlan ? 1 : 0;
+    const invokeVariantStartIndex = failureVariantIndex + 1;
+    return {
+        type: "json_schema",
+        name: "planner_decision",
+        strict: true,
+        postValidatedSchemaConstraints: [
+            ...(!selectingPlan
+                ? [
+                    {
+                        keyword: "maxLength",
+                        path: `${structuredDecisionVariantSchemaPath(0, variants.length)}/properties/result/maxLength`,
+                    },
+                ]
+                : []),
+            {
+                keyword: "maxLength",
+                path: `${structuredDecisionVariantSchemaPath(failureVariantIndex, variants.length)}/properties/reason/maxLength`,
+            },
+            ...invokeVariantDefinitions.flatMap(({ worker }, index) => invokeRoleMaxLengthConstraints(planContext, variants.length, invokeVariantStartIndex + index, worker && workingDirectoryRequired)),
+        ],
+        schema: createStructuredDecisionEnvelopeSchema(variants),
+    };
+}
+function invokeRoleSchema(params) {
+    return exactObject({
+        action: literal("invoke_role"),
+        roleId: {
+            type: "string",
+            enum: [...params.availableChildRoleIds],
+        },
+        ...(params.workingDirectoryRequired
+            ? {
+                workingDirectory: boundedText(ROLE_CALL_WORKING_DIRECTORY_MAX_LENGTH),
+            }
+            : {}),
+        ...(params.workerCapabilityScopeSchema
+            ? {
+                workerCapabilityScope: params.workerCapabilityScopeSchema,
+            }
+            : {}),
+        ...(params.planContext?.mode === "declare"
+            ? {
+                plan: exactObject({
+                    summary: boundedText(PLANNER_OBJECTIVE_MAX_LENGTH),
+                    items: {
+                        type: "array",
+                        minItems: 1,
+                        maxItems: params.planContext.maxItems,
+                        items: exactObject({
+                            title: boundedText(ROLE_CALL_PLAN_ITEM_TITLE_MAX_LENGTH),
+                            objective: boundedText(PLANNER_OBJECTIVE_MAX_LENGTH),
+                        }),
+                    },
+                }),
+                selectedItemIndexes: selectedItemIndexesSchema(params.planContext.maxItems),
+            }
+            : params.planContext?.mode === "extend"
+                ? {
+                    extension: exactObject({
+                        items: {
+                            type: "array",
+                            minItems: 1,
+                            maxItems: params.planContext.maxItems,
+                            items: exactObject({
+                                title: boundedText(ROLE_CALL_PLAN_ITEM_TITLE_MAX_LENGTH),
+                                objective: boundedText(PLANNER_OBJECTIVE_MAX_LENGTH),
+                            }),
+                        },
+                    }),
+                    selectedItemIndexes: selectedItemIndexesSchema(params.planContext.maxItems),
+                }
+                : params.planContext?.mode === "select"
+                    ? {
+                        planItemIds: {
+                            type: "array",
+                            minItems: 1,
+                            maxItems: params.planContext.pendingItems.length,
+                            items: {
+                                type: "string",
+                                enum: params.planContext.pendingItems.map((item) => item.itemId),
+                            },
+                        },
+                    }
+                    : { objective: boundedText(PLANNER_OBJECTIVE_MAX_LENGTH) }),
+    });
+}
+function selectedItemIndexesSchema(maxItems) {
+    return {
+        type: "array",
+        minItems: 1,
+        maxItems,
+        items: {
+            type: "integer",
+            minimum: 0,
+            maximum: Math.max(0, maxItems - 1),
+        },
+    };
+}
+function invokeRoleMaxLengthConstraints(planContext, variantCount, variantIndex, includeWorkingDirectory) {
+    const invokePath = structuredDecisionVariantSchemaPath(variantIndex, variantCount);
+    const workingDirectoryConstraints = includeWorkingDirectory
+        ? [
+            {
+                keyword: "maxLength",
+                path: `${invokePath}/properties/workingDirectory/maxLength`,
+            },
+        ]
+        : [];
+    if (planContext?.mode === "select") {
+        return workingDirectoryConstraints;
+    }
+    if (planContext?.mode === "extend") {
+        return [
+            ...workingDirectoryConstraints,
+            {
+                keyword: "maxLength",
+                path: `${invokePath}/properties/extension/properties/items/items/properties/title/maxLength`,
+            },
+            {
+                keyword: "maxLength",
+                path: `${invokePath}/properties/extension/properties/items/items/properties/objective/maxLength`,
+            },
+        ];
+    }
+    if (planContext?.mode === "declare") {
+        return [
+            ...workingDirectoryConstraints,
+            {
+                keyword: "maxLength",
+                path: `${invokePath}/properties/plan/properties/summary/maxLength`,
+            },
+            {
+                keyword: "maxLength",
+                path: `${invokePath}/properties/plan/properties/items/items/properties/title/maxLength`,
+            },
+            {
+                keyword: "maxLength",
+                path: `${invokePath}/properties/plan/properties/items/items/properties/objective/maxLength`,
+            },
+        ];
+    }
+    return [
+        ...workingDirectoryConstraints,
+        {
+            keyword: "maxLength",
+            path: `${invokePath}/properties/objective/maxLength`,
+        },
+    ];
+}
+export function normalizeAvailableChildRoleIds(values) {
+    if (!Array.isArray(values)) {
+        throw new Error("planner_available_child_roles_invalid");
+    }
+    const unique = new Set();
+    for (const value of values) {
+        if (!isPlannerChildRoleId(value) || unique.has(value)) {
+            throw new Error("planner_available_child_roles_invalid");
+        }
+        unique.add(value);
+    }
+    return Object.freeze([...unique]);
+}
+function exactObject(properties) {
+    return {
+        type: "object",
+        properties,
+        required: Object.keys(properties),
+        additionalProperties: false,
+    };
+}
+function literal(value) {
+    return { type: "string", enum: [value] };
+}
+function boundedText(maxLength) {
+    return {
+        type: "string",
+        minLength: 1,
+        maxLength,
+    };
+}

package/dist/src/runtime/steps/planner-decision/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./contracts.js";
+export * from "./format.js";
+export * from "./input.js";
+export * from "./parser.js";
+export * from "./plan.js";
+export * from "./prompt.js";
+export * from "./resume.js";
+export * from "./run.js";
+export * from "./tool-results.js";

package/dist/src/runtime/steps/planner-decision/index.js

@@ -0,0 +1,9 @@
+export * from "./contracts.js";
+export * from "./format.js";
+export * from "./input.js";
+export * from "./parser.js";
+export * from "./plan.js";
+export * from "./prompt.js";
+export * from "./resume.js";
+export * from "./run.js";
+export * from "./tool-results.js";

package/dist/src/runtime/steps/planner-decision/input.d.ts

@@ -0,0 +1,35 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import type { RequestContextProjection } from "../../context/request-context-contracts.js";
+import { type RequestToolResultsView } from "../../context/request-tool-results.js";
+import { type RoleCallFrame, type RoleCallChildReturnCommit, type RoleCallDependencyResult, type RoleCallLedger, type RoleCallLedgerHead, type RoleChildReturnContext } from "../../orchestration/role-calls/index.js";
+import { type WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
+import { type RequestWorkerCapabilityProviderSource } from "../../request/execution-scope.js";
+import type { RequestExecutionSeed } from "../../request/contracts.js";
+import { PLANNER_DECISION_MODEL_STEP, type PlannerChildRoleId, type PlannerDecisionDiagnosticContext, type PlannerDecisionPlanContext, type PlannerDecisionSelectionKind } from "./contracts.js";
+export type PlannerDecisionInputRequest = Pick<RequestExecutionSeed, "requestId" | "prompt" | "runnerConfig" | "agentMode" | "modelPreference" | "modelPolicy"> & Partial<Pick<RequestExecutionSeed, "onEvent" | "temporalContext">> & RequestWorkerCapabilityProviderSource;
+export type PlannerDecisionProgressSource = Readonly<{
+    kind: "role_child";
+    ledger: RoleCallLedger;
+    commit: RoleCallChildReturnCommit;
+}>;
+export declare function buildPlannerDecisionInput(request: PlannerDecisionInputRequest, options: Readonly<{
+    call: RoleCallFrame;
+    availableChildRoleIds: readonly PlannerChildRoleId[];
+    toolResults: RequestToolResultsView;
+    dependencyHead?: RoleCallLedgerHead;
+    progress?: PlannerDecisionProgressSource;
+    planContext?: PlannerDecisionPlanContext;
+    diagnostic?: PlannerDecisionDiagnosticContext;
+}>): {
+    context: RequestContextProjection;
+    format: ModelGatewayJsonSchemaFormat;
+    modelStep: typeof PLANNER_DECISION_MODEL_STEP;
+    diagnostic: PlannerDecisionDiagnosticContext;
+    allowedActions: readonly PlannerDecisionSelectionKind[];
+    availableChildRoleIds: readonly PlannerChildRoleId[];
+    dependencyResults: readonly RoleCallDependencyResult[];
+    availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];
+    inheritedWorkingDirectory?: string;
+    planContext?: PlannerDecisionPlanContext;
+    childResume?: RoleChildReturnContext;
+};

package/dist/src/runtime/steps/planner-decision/input.js

@@ -0,0 +1,218 @@
+import { resolveConfiguredStepInstructionMetadata } from "../../config/runner/step-instructions.js";
+import { projectRequestContext } from "../../context/request-context.js";
+import { buildRequestTemporalContextMessage } from "../../context/request-temporal-context.js";
+import { buildRequestSourceMessage, projectRequestSource, } from "../../context/request-source.js";
+import { buildRequestToolResultsMessage, } from "../../context/request-tool-results.js";
+import { resolveModelContextBudget } from "../../model/model-context-budget.js";
+import { projectRoleCallDependencyResults, projectRoleChildReturnContext, } from "../../orchestration/role-calls/index.js";
+import { projectWorkerCapabilityCatalogGroups, } from "../../orchestration/worker-capabilities/index.js";
+import { resolveRequestWorkerCapabilityCatalog, } from "../../request/execution-scope.js";
+import { PLANNER_DECISION_ACTIONS, PLANNER_DECISION_MODEL_STEP, projectPlannerDecisionCallIdentity, } from "./contracts.js";
+import { tracePlannerChildResultsProjected, tracePlannerContextProjected, } from "./diagnostics.js";
+import { createPlannerDecisionFormat, normalizeAvailableChildRoleIds, } from "./format.js";
+import { normalizePlannerDecisionPlanContext, plannerPlanAllowsInvocation, } from "./plan.js";
+import { buildPlannerDecisionInstructions } from "./prompt.js";
+import { buildPlannerChildContinuationPart } from "./resume.js";
+import { projectPlannerToolResults } from "./tool-results.js";
+export function buildPlannerDecisionInput(request, options) {
+    const callIdentity = projectPlannerDecisionCallIdentity(options.call);
+    const diagnostic = options.diagnostic ??
+        {
+            requestId: request.requestId,
+            modelStep: PLANNER_DECISION_MODEL_STEP,
+            ...callIdentity,
+        };
+    const configuredChildRoleIds = normalizeAvailableChildRoleIds(options.availableChildRoleIds);
+    const availableWorkerCapabilityCatalog = configuredChildRoleIds.includes("worker")
+        ? projectWorkerCapabilityCatalogGroups(resolveRequestWorkerCapabilityCatalog(request).getDescriptors())
+        : Object.freeze([]);
+    const availableChildRoleIds = configuredChildRoleIds;
+    const inheritedWorkingDirectory = options.call.workingDirectory;
+    const planContext = options.planContext
+        ? normalizePlannerDecisionPlanContext(options.planContext)
+        : undefined;
+    const childInvocationAvailable = availableChildRoleIds.length > 0 &&
+        plannerPlanAllowsInvocation(planContext);
+    const childResume = options.progress
+        ? projectRoleChildReturnContext(options.progress.ledger, options.progress.commit)
+        : undefined;
+    validatePlannerCanonicalContext({
+        requestId: request.requestId,
+        call: options.call,
+        progressSource: options.progress,
+        childResume,
+    });
+    const dependencyResults = options.dependencyHead
+        ? projectRoleCallDependencyResults(options.dependencyHead, options.call)
+        : requireNoUnresolvedDependencies(options.call);
+    const allowedActions = Object.freeze([
+        ...(planContext?.mode === "select"
+            ? []
+            : [PLANNER_DECISION_ACTIONS[0]]),
+        PLANNER_DECISION_ACTIONS[1],
+        ...(childInvocationAvailable ? [PLANNER_DECISION_ACTIONS[2]] : []),
+    ]);
+    const format = createPlannerDecisionFormat({
+        availableChildRoleIds,
+        availableWorkerCapabilityCatalog,
+        ...(inheritedWorkingDirectory !== undefined
+            ? { inheritedWorkingDirectory }
+            : {}),
+        ...(planContext ? { planContext } : {}),
+    });
+    const childContinuationPart = childResume
+        ? buildPlannerChildContinuationPart({
+            resume: childResume,
+            currentCallId: callIdentity.callId,
+            currentInvocationAttempt: callIdentity.invocationAttempt,
+            ...(planContext ? { planContext } : {}),
+        })
+        : undefined;
+    const requestSource = projectRequestSource({
+        requestId: request.requestId,
+        prompt: request.prompt,
+        modelStep: PLANNER_DECISION_MODEL_STEP,
+        callId: callIdentity.callId,
+    });
+    const toolResultsProjection = projectPlannerToolResults(options.toolResults);
+    const referenceMessages = Object.freeze([
+        ...(request.temporalContext
+            ? [buildRequestTemporalContextMessage(request.temporalContext)]
+            : []),
+        buildRequestSourceMessage(requestSource),
+        ...(toolResultsProjection.view.results.length > 0
+            ? [buildRequestToolResultsMessage(toolResultsProjection.view)]
+            : []),
+    ]);
+    const budget = resolveModelContextBudget({
+        runnerConfig: request.runnerConfig,
+        agentMode: request.agentMode,
+        modelStep: PLANNER_DECISION_MODEL_STEP,
+        ...(request.modelPreference
+            ? { modelPreference: request.modelPreference }
+            : {}),
+        ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
+    });
+    const configuredInstructionMetadata = resolveConfiguredStepInstructionMetadata({
+        runnerConfig: request.runnerConfig,
+        modelStep: PLANNER_DECISION_MODEL_STEP,
+    });
+    const instructions = buildPlannerDecisionInstructions({
+        childRolesAvailable: childInvocationAvailable,
+        hasCompletedChildResults: childResume !== undefined,
+        hasDependencyResults: dependencyResults.length > 0,
+        workerRoleAvailable: availableChildRoleIds.includes("worker"),
+        workerWorkingDirectoryInherited: inheritedWorkingDirectory !== undefined,
+        workerCapabilityCatalogAvailable: availableWorkerCapabilityCatalog.length > 0,
+        ...(planContext ? { planContext } : {}),
+    });
+    const context = projectRequestContext({
+        instructions,
+        format,
+        historyMessages: [],
+        prompt: JSON.stringify({
+            kind: "runtime_planner_assignment",
+            callId: callIdentity.callId,
+            parentCallId: callIdentity.parentCallId,
+            depth: callIdentity.depth,
+            invocationAttempt: callIdentity.invocationAttempt,
+            objective: options.call.objective,
+            ...(inheritedWorkingDirectory !== undefined
+                ? { workingDirectory: inheritedWorkingDirectory }
+                : {}),
+            availableChildRoleIds,
+            ...(availableWorkerCapabilityCatalog.length > 0
+                ? { availableWorkerCapabilityCatalog }
+                : {}),
+            ...(dependencyResults.length > 0 ? { dependencyResults } : {}),
+            ...(planContext ? { planContext } : {}),
+            completedChildResultCount: childResume?.completedChildren.length ?? 0,
+        }),
+        referenceMessages,
+        ...(childContinuationPart
+            ? { continuationParts: [childContinuationPart] }
+            : {}),
+        budget,
+        diagnostic,
+        ...(request.onEvent ? { onEvent: request.onEvent } : {}),
+        deferCompactionFailure: true,
+    });
+    tracePlannerContextProjected({
+        diagnostic,
+        context,
+        format,
+        objectiveLength: options.call.objective.length,
+        workingDirectoryInherited: inheritedWorkingDirectory !== undefined,
+        workingDirectoryLength: inheritedWorkingDirectory?.length ?? 0,
+        availableChildRoleIds,
+        workerCapabilityCatalogGroupIds: availableWorkerCapabilityCatalog.map((group) => group.groupId),
+        workerCapabilityCatalogMemberCount: availableWorkerCapabilityCatalog.reduce((total, group) => total + group.memberCount, 0),
+        referenceMessageCount: referenceMessages.length,
+        continuationMessageCount: childContinuationPart?.messages.length ?? 0,
+        completedChildResultCount: childResume?.completedChildren.length ?? 0,
+        completedChildSummaryLength: childResume?.completedChildren.reduce((total, child) => total + child.summary.length, 0) ?? 0,
+        dependencyResultRefs: dependencyResults.map((result) => result.resultRef),
+        dependencyResultSummaryLength: dependencyResults.reduce((total, result) => total + result.summary.length, 0),
+        sourceToolResultCount: toolResultsProjection.sourceResultCount,
+        projectedToolResultCount: toolResultsProjection.view.results.length,
+        supersededToolResultCount: toolResultsProjection.supersededResultCount,
+        retainedFailedToolResultCount: toolResultsProjection.retainedFailedResultCount,
+        retainedUntargetedToolResultCount: toolResultsProjection.retainedUntargetedResultCount,
+        allowedActions,
+        configuredInstructionBlockCount: configuredInstructionMetadata.blockCount,
+        configuredInstructionCharacterCount: configuredInstructionMetadata.characterCount,
+        configuredInstructionRefs: configuredInstructionMetadata.refs,
+        configuredInstructionContentHashes: configuredInstructionMetadata.contentHashes,
+        ...(planContext ? { planContext } : {}),
+    });
+    if (childResume) {
+        tracePlannerChildResultsProjected({
+            diagnostic,
+            resume: childResume,
+            continuationMessageCount: childContinuationPart?.messages.length ?? 0,
+        });
+    }
+    return {
+        context,
+        format,
+        modelStep: PLANNER_DECISION_MODEL_STEP,
+        diagnostic,
+        allowedActions,
+        availableChildRoleIds,
+        dependencyResults,
+        availableWorkerCapabilityCatalog,
+        ...(inheritedWorkingDirectory !== undefined
+            ? { inheritedWorkingDirectory }
+            : {}),
+        ...(planContext ? { planContext } : {}),
+        ...(childResume ? { childResume } : {}),
+    };
+}
+function requireNoUnresolvedDependencies(call) {
+    if (call.dependencyResultRefs.length > 0) {
+        throw new Error("planner_dependency_source_missing");
+    }
+    return Object.freeze([]);
+}
+function validatePlannerCanonicalContext(params) {
+    const childCount = params.call.childCallIds.length;
+    if ((childCount === 0 && params.childResume !== undefined) ||
+        (childCount > 0 && params.childResume === undefined)) {
+        throw new Error("planner_child_resume_presence_invalid");
+    }
+    if (!params.progressSource) {
+        if (params.call.activationCount !== 1) {
+            throw new Error("planner_initial_activation_invalid");
+        }
+        return;
+    }
+    const head = params.progressSource.commit.head;
+    const canonicalCall = head?.state.calls.find((candidate) => candidate.callId === head.state.activeCallId);
+    if (head?.state.requestId !== params.requestId ||
+        canonicalCall !== params.call ||
+        params.childResume?.callerCallId !== params.call.callId ||
+        params.childResume.invocationAttempt !== params.call.activationCount ||
+        params.childResume.completedChildren.length !== childCount) {
+        throw new Error("planner_child_resume_source_mismatch");
+    }
+}

package/dist/src/runtime/steps/planner-decision/parser.d.ts

@@ -0,0 +1,9 @@
+import type { WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
+import { type PlannerDecisionDiagnosticContext, type PlannerDecisionPlanContext, type PlannerDecisionParseResult, type PlannerChildRoleId } from "./contracts.js";
+export declare function parsePlannerDecisionOutput(text: string, options?: Readonly<{
+    availableChildRoleIds?: readonly PlannerChildRoleId[];
+    availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
+    inheritedWorkingDirectory?: string;
+    planContext?: PlannerDecisionPlanContext;
+    diagnostic?: PlannerDecisionDiagnosticContext;
+}>): PlannerDecisionParseResult;