@happier-dev/stack 0.2.1-preview.1775586714.26562 → 0.2.11

package/node_modules/@happier-dev/protocol/dist/sessionAgentTransition.d.ts

@@ -0,0 +1,409 @@
+import { z } from 'zod';
+/**
+ * Same-Session cross-Agent continuation — the frozen shared contract.
+ *
+ * Both trees implement THIS shape. The outer request/result is closed and
+ * versioned; the nested user input reuses the already-canonical user-message
+ * schema so no second message vocabulary exists.
+ *
+ * Machine RPC:      session.agentTransition
+ * Inspection RPC:   session.continuation.inspect
+ */
+/**
+ * The smallest portable intersection of the two trees' Session authoring field
+ * catalogs. Every field below is present with the same shape in BOTH catalogs
+ * (`agentId`, `modelId`, `acpSessionModeId`, `sessionConfigOptionOverrides`).
+ *
+ * Deliberately NOT used here:
+ * - `kind:'builtInAgent'` target carriers with a hard-coded agent-id enum. The
+ *   agent id is a free catalog identifier resolved and validated by each
+ *   daemon's Agent catalog, so adding an Agent never requires a wire change.
+ * - `AgentExecutionTargetV1` / `SessionModelSelectionV1`. Both are dev-only
+ *   (zero occurrences in the predecessor tree) and cannot be a shared shape.
+ *
+ * Each daemon adapts this selection into its own internal target/model owners.
+ * The adapters are fixed, so no downstream lane has to re-decide them:
+ *
+ * successor (`dev`)
+ * - `agentId` -> Agent catalog resolution -> `AgentExecutionTargetV1`
+ *   (`packages/protocol/src/agents/executionTargetV1.ts`).
+ * - `modelId` + `providerConnectionId` -> `SessionModelSelectionV1`
+ *   (`packages/protocol/src/providers/selection/v1.ts`).
+ * - `acpSessionModeId` -> the existing agent/ACP session-mode owner.
+ * - `sessionConfigOptionOverrides` -> carried through unchanged.
+ *
+ * predecessor (`remote-dev`, this tree)
+ * - `agentId` -> validated against `CATALOG_AGENT_IDS`, then mapped onto the
+ *   INTERNAL `{ kind: 'builtInAgent', agentId }` carrier in
+ *   `apps/cli/src/rpc/handlers/spawnSessionOptionsContract.ts`. That carrier is
+ *   an internal transport detail and never appears on this wire.
+ * - `modelId` -> the flat `modelId` spawn field.
+ * - `acpSessionModeId` -> the flat `agentModeId` spawn field.
+ * - `sessionConfigOptionOverrides` -> the flat field of the same name.
+ * - `providerConnectionId` -> NOT representable in this tree. Inspection reports it
+ *   unavailable and the final mutation rejects with `target_unavailable`; it is
+ *   never silently dropped.
+ */
+export declare const SessionAgentTransitionSelectionV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    agentId: z.ZodString;
+    modelId: z.ZodOptional<z.ZodString>;
+    providerConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    acpSessionModeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sessionConfigOptionOverrides: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        updatedAt: z.ZodNumber;
+        overrides: z.ZodRecord<z.ZodString, z.ZodObject<{
+            updatedAt: z.ZodNumber;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$strict>;
+export type SessionAgentTransitionSelectionV1 = z.infer<typeof SessionAgentTransitionSelectionV1Schema>;
+/**
+ * The exact user input carried by the transition. It is the canonical
+ * user-message request with `localId` promoted from optional to REQUIRED: that
+ * localId is the transition's dedupe identity, divider correlation key, and
+ * draft compare-clear key, so it can never be absent.
+ *
+ * `safeExtend` (not `extend`) retains the canonical sanitizer and refinement.
+ * The transition then closes its own mutation boundary; forward-compatible
+ * message metadata remains inside the canonical opaque `meta` record.
+ */
+export declare const SessionAgentTransitionInputV1Schema: z.ZodObject<{
+    text: z.ZodString;
+    meta: z.ZodDefault<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodTransform<{
+        [x: string]: unknown;
+    }, Record<string, unknown>>>>;
+    localId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}, z.core.$strict>;
+export type SessionAgentTransitionInputV1 = z.infer<typeof SessionAgentTransitionInputV1Schema>;
+export declare const SessionAgentTransitionRequestV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    expectedCurrentAgentId: z.ZodString;
+    selection: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        agentId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        providerConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        acpSessionModeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sessionConfigOptionOverrides: z.ZodOptional<z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            updatedAt: z.ZodNumber;
+            overrides: z.ZodRecord<z.ZodString, z.ZodObject<{
+                updatedAt: z.ZodNumber;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$strict>;
+    input: z.ZodObject<{
+        text: z.ZodString;
+        meta: z.ZodDefault<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodTransform<{
+            [x: string]: unknown;
+        }, Record<string, unknown>>>>;
+        localId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SessionAgentTransitionRequestV1 = z.infer<typeof SessionAgentTransitionRequestV1Schema>;
+/**
+ * Definite rejections with the source PROVABLY untouched and still running.
+ *
+ * `source_stop_failed` belongs here and only here: it is the stop result that
+ * PROVES the source is still running, which is the one stop outcome whose
+ * `sourceEffect: 'none'` promise is truthful. An UNCONFIRMED stop
+ * (`physical_stop_unconfirmed`, `stopped_projection_unconfirmed`) means the
+ * source may already be gone, so it maps to `outcome_unknown` instead — never
+ * to a rejection that claims an untouched source.
+ */
+export declare const SESSION_AGENT_TRANSITION_REJECTED_CODES_V1: readonly ['unsupported_operation', 'forbidden', 'same_target', 'stale_selection', 'target_unavailable', 'source_not_idle', 'source_stop_failed'];
+/**
+ * The source is CONFIRMED stopped and NOTHING was committed. This is a known
+ * state, not an indeterminate one: the bounded context pass and the current-view
+ * CAS both run after `requestSessionStop` succeeds and before any write.
+ *
+ * The Session remains owned by the source Agent. Presentation reconciles this
+ * established effect with canonical Session and input-custody facts.
+ */
+export declare const SESSION_AGENT_TRANSITION_SOURCE_STOPPED_CODES_V1: readonly ['context_unavailable', 'cutover_conflict'];
+/**
+ * The target current view IS committed: the source is stopped and the Session is
+ * now the target Agent. Presentation reconciles this established effect with
+ * canonical Session and input-custody facts.
+ *
+ * Missing, conflicting, or unreadable/unverifiable divider evidence produces
+ * the one public `divider_unavailable` result. The storage-specific evidence
+ * remains internal to the coordinator, but every such result knows the Session
+ * is the target and must not degrade to `outcome_unknown`.
+ *
+ * `input_admission_failed` means admission did not happen; `input_rejected` is a
+ * definite rejection by the canonical message owner. Both are only reachable
+ * after cutover, so neither may ride `rejected`.
+ */
+export declare const SESSION_AGENT_TRANSITION_CURRENT_VIEW_COMMITTED_CODES_V1: readonly ['divider_unavailable', 'target_start_failed', 'input_admission_failed', 'input_rejected'];
+export declare const SessionAgentTransitionRejectedCodeV1Schema: z.ZodEnum<{
+    forbidden: "forbidden";
+    same_target: "same_target";
+    source_not_idle: "source_not_idle";
+    source_stop_failed: "source_stop_failed";
+    stale_selection: "stale_selection";
+    target_unavailable: "target_unavailable";
+    unsupported_operation: "unsupported_operation";
+}>;
+export type SessionAgentTransitionRejectedCodeV1 = z.infer<typeof SessionAgentTransitionRejectedCodeV1Schema>;
+export declare const SessionAgentTransitionSourceStoppedCodeV1Schema: z.ZodEnum<{
+    context_unavailable: "context_unavailable";
+    cutover_conflict: "cutover_conflict";
+}>;
+export type SessionAgentTransitionSourceStoppedCodeV1 = z.infer<typeof SessionAgentTransitionSourceStoppedCodeV1Schema>;
+export declare const SessionAgentTransitionCurrentViewCommittedCodeV1Schema: z.ZodEnum<{
+    divider_unavailable: "divider_unavailable";
+    input_admission_failed: "input_admission_failed";
+    input_rejected: "input_rejected";
+    target_start_failed: "target_start_failed";
+}>;
+export type SessionAgentTransitionCurrentViewCommittedCodeV1 = z.infer<typeof SessionAgentTransitionCurrentViewCommittedCodeV1Schema>;
+/** Every code the `partially_applied` arm can carry, at either depth. */
+export declare const SESSION_AGENT_TRANSITION_PARTIAL_CODES_V1: readonly ["context_unavailable", "cutover_conflict", "divider_unavailable", "target_start_failed", "input_admission_failed", "input_rejected"];
+export declare const SessionAgentTransitionPartialCodeV1Schema: z.ZodEnum<{
+    context_unavailable: "context_unavailable";
+    cutover_conflict: "cutover_conflict";
+    divider_unavailable: "divider_unavailable";
+    input_admission_failed: "input_admission_failed";
+    input_rejected: "input_rejected";
+    target_start_failed: "target_start_failed";
+}>;
+export type SessionAgentTransitionPartialCodeV1 = z.infer<typeof SessionAgentTransitionPartialCodeV1Schema>;
+/**
+ * Every transition code. Each one is reachable from exactly one result arm, and
+ * each arm names a distinct established effect.
+ *
+ * `reconciliation_required` is deliberately absent. Once `partially_applied`
+ * carries both known partial depths, the only remaining case is a genuinely
+ * indeterminate one — which is exactly the meaning of the bare `outcome_unknown`
+ * arm. Keeping a code for it would let a daemon name a state it cannot actually
+ * establish.
+ */
+export declare const SESSION_AGENT_TRANSITION_ERROR_CODES_V1: readonly ["unsupported_operation", "forbidden", "same_target", "stale_selection", "target_unavailable", "source_not_idle", "source_stop_failed", "context_unavailable", "cutover_conflict", "divider_unavailable", "target_start_failed", "input_admission_failed", "input_rejected"];
+export declare const SessionAgentTransitionErrorCodeV1Schema: z.ZodEnum<{
+    context_unavailable: "context_unavailable";
+    cutover_conflict: "cutover_conflict";
+    divider_unavailable: "divider_unavailable";
+    forbidden: "forbidden";
+    input_admission_failed: "input_admission_failed";
+    input_rejected: "input_rejected";
+    same_target: "same_target";
+    source_not_idle: "source_not_idle";
+    source_stop_failed: "source_stop_failed";
+    stale_selection: "stale_selection";
+    target_start_failed: "target_start_failed";
+    target_unavailable: "target_unavailable";
+    unsupported_operation: "unsupported_operation";
+}>;
+export type SessionAgentTransitionErrorCodeV1 = z.infer<typeof SessionAgentTransitionErrorCodeV1Schema>;
+/**
+ * `accepted` means the target current view and divider committed AND the exact
+ * localId received canonical message admission. It does not claim provider
+ * acceptance.
+ */
+export declare const SessionAgentTransitionResultV1Schema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"accepted">;
+    localId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"rejected">;
+    code: z.ZodEnum<{
+        forbidden: "forbidden";
+        same_target: "same_target";
+        source_not_idle: "source_not_idle";
+        source_stop_failed: "source_stop_failed";
+        stale_selection: "stale_selection";
+        target_unavailable: "target_unavailable";
+        unsupported_operation: "unsupported_operation";
+    }>;
+    sourceEffect: z.ZodLiteral<"none">;
+}, z.core.$strict>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"partially_applied">;
+    localId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    applied: z.ZodLiteral<"source_stopped">;
+    code: z.ZodEnum<{
+        context_unavailable: "context_unavailable";
+        cutover_conflict: "cutover_conflict";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"partially_applied">;
+    localId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    applied: z.ZodLiteral<"current_view_committed">;
+    code: z.ZodEnum<{
+        divider_unavailable: "divider_unavailable";
+        input_admission_failed: "input_admission_failed";
+        input_rejected: "input_rejected";
+        target_start_failed: "target_start_failed";
+    }>;
+}, z.core.$strict>], "applied">, z.ZodObject<{
+    type: z.ZodLiteral<"outcome_unknown">;
+    localId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}, z.core.$strict>]>;
+export type SessionAgentTransitionResultV1 = z.infer<typeof SessionAgentTransitionResultV1Schema>;
+export declare const SessionContinuationInspectionRequestV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    sourceSessionId: z.ZodString;
+    selection: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        agentId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        providerConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        acpSessionModeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sessionConfigOptionOverrides: z.ZodOptional<z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            updatedAt: z.ZodNumber;
+            overrides: z.ZodRecord<z.ZodString, z.ZodObject<{
+                updatedAt: z.ZodNumber;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SessionContinuationInspectionRequestV1 = z.infer<typeof SessionContinuationInspectionRequestV1Schema>;
+/**
+ * `operation_unavailable` is the collapsed transport outcome: the machine RPC
+ * returned METHOD_NOT_AVAILABLE, which a daemon that predates the operation and
+ * an unreachable machine both produce. The daemon cannot distinguish them and
+ * this contract does not pretend it can — see
+ * {@link resolveSessionContinuationUnavailablePresentationV1}.
+ */
+export declare const SessionContinuationInspectionUnavailableReasonV1Schema: z.ZodEnum<{
+    operation_unavailable: "operation_unavailable";
+    target_unavailable: "target_unavailable";
+    unsupported_session: "unsupported_session";
+}>;
+export type SessionContinuationInspectionUnavailableReasonV1 = z.infer<typeof SessionContinuationInspectionUnavailableReasonV1Schema>;
+export declare const SessionContinuationInspectionV1Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"available">;
+    protocolVersion: z.ZodLiteral<1>;
+    sameSessionTransition: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"unavailable">;
+    reason: z.ZodEnum<{
+        operation_unavailable: "operation_unavailable";
+        target_unavailable: "target_unavailable";
+        unsupported_session: "unsupported_session";
+    }>;
+}, z.core.$strict>], "type">;
+export type SessionContinuationInspectionV1 = z.infer<typeof SessionContinuationInspectionV1Schema>;
+/**
+ * Machine reachability as the client already knows it, independent of this RPC.
+ * Both trees expose `isMachineOnline(machine)` at
+ * `apps/ui/sources/utils/sessions/machineUtils.ts`; `'unknown'` covers the case
+ * where no machine record has hydrated yet.
+ */
+export type SessionContinuationMachinePresenceV1 = 'online' | 'offline' | 'unknown';
+export declare const SessionContinuationUnavailablePresentationV1Schema: z.ZodEnum<{
+    machine_offline: "machine_offline";
+    target_unavailable: "target_unavailable";
+    unsupported_session: "unsupported_session";
+    update_cli: "update_cli";
+    update_or_reconnect: "update_or_reconnect";
+}>;
+export type SessionContinuationUnavailablePresentationV1 = z.infer<typeof SessionContinuationUnavailablePresentationV1Schema>;
+/**
+ * The transport collapses "old daemon" and "machine unreachable" into one
+ * METHOD_NOT_AVAILABLE, so the RPC alone cannot tell them apart. The CLIENT can,
+ * by combining the inspection reason with the machine-presence fact it already
+ * holds. This is the one owner of that composition — UI surfaces consume it
+ * rather than each re-deriving the three-way branch.
+ */
+export declare function resolveSessionContinuationUnavailablePresentationV1(params: Readonly<{
+    reason: SessionContinuationInspectionUnavailableReasonV1;
+    machinePresence: SessionContinuationMachinePresenceV1;
+}>): SessionContinuationUnavailablePresentationV1;
+/**
+ * Rebuilds the activation brief one transition divider stands for.
+ *
+ * Nothing is stored to show: `replaySeedV1.seedText` is blanked the instant the
+ * target Agent accepts it, and the metadata record keeps one seed per Session,
+ * so a twice-switched Session has already lost the first. The divider's own
+ * BOUNDS are the surviving inputs, and running the SAME bounded context pass
+ * between them reproduces what the target was handed without persisting a
+ * second copy of the conversation.
+ *
+ * It runs on the machine because that is where the pass runs: the retrieval
+ * walks the fork chain, opens the Session's stored content and decodes every
+ * provider dialect through the daemon's transcript decoder. A client that
+ * re-derived the dialog from its own rendered transcript would be a SECOND
+ * decision-maker about what the Agent was sent, free to disagree with the first
+ * — which is the one thing a surface claiming to show the handoff must not be.
+ *
+ * Read-only and effect-free: it reserves nothing, writes nothing, and grants no
+ * authority. A stale answer can only mislead a label.
+ */
+export declare const SessionAgentTransitionBriefPreviewRequestV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    sourceCutoffSeqInclusive: z.ZodNumber;
+    returningAgentLastSeenSeqInclusive: z.ZodOptional<z.ZodNumber>;
+    sourceAgentId: z.ZodString;
+    targetAgentId: z.ZodString;
+}, z.core.$strict>;
+export type SessionAgentTransitionBriefPreviewRequestV1 = z.infer<typeof SessionAgentTransitionBriefPreviewRequestV1Schema>;
+/**
+ * `operation_unavailable` is the collapsed transport outcome, exactly as in
+ * {@link SessionContinuationInspectionUnavailableReasonV1Schema}: METHOD_NOT_AVAILABLE
+ * is produced both by a daemon predating the operation and by an unreachable
+ * machine, and the same client-side presentation owner splits them.
+ *
+ * `source_unreadable` is the daemon's own answer: the bounded retrieval failed
+ * or the Session's content could not be opened, so what it holds is unknown.
+ * That is NOT `empty`, and collapsing the two would show "nothing was carried
+ * over" for a conversation that was.
+ */
+export declare const SessionAgentTransitionBriefPreviewUnavailableReasonV1Schema: z.ZodEnum<{
+    operation_unavailable: "operation_unavailable";
+    source_unreadable: "source_unreadable";
+    unsupported_session: "unsupported_session";
+}>;
+export type SessionAgentTransitionBriefPreviewUnavailableReasonV1 = z.infer<typeof SessionAgentTransitionBriefPreviewUnavailableReasonV1Schema>;
+export declare const SessionAgentTransitionBriefPreviewV1Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"rebuilt">;
+    protocolVersion: z.ZodLiteral<1>;
+    briefText: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"empty">;
+    protocolVersion: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"unavailable">;
+    reason: z.ZodEnum<{
+        operation_unavailable: "operation_unavailable";
+        source_unreadable: "source_unreadable";
+        unsupported_session: "unsupported_session";
+    }>;
+}, z.core.$strict>], "type">;
+export type SessionAgentTransitionBriefPreviewV1 = z.infer<typeof SessionAgentTransitionBriefPreviewV1Schema>;
+/**
+ * The persisted draft intent. Selecting another Agent is effect-free; this value
+ * only arms the next true submission.
+ *
+ * It carries no acknowledgment flag, timer, TTL, operation id, or progress
+ * phase: the existing draft envelope owns timestamps, revisions, and cleanup.
+ */
+export declare const ComposerAgentContinuationIntentV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    mode: z.ZodLiteral<"same_session">;
+    sourceAgentId: z.ZodString;
+    selection: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        agentId: z.ZodString;
+        modelId: z.ZodOptional<z.ZodString>;
+        providerConnectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        acpSessionModeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sessionConfigOptionOverrides: z.ZodOptional<z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            updatedAt: z.ZodNumber;
+            overrides: z.ZodRecord<z.ZodString, z.ZodObject<{
+                updatedAt: z.ZodNumber;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ComposerAgentContinuationIntentV1 = z.infer<typeof ComposerAgentContinuationIntentV1Schema>;
+//# sourceMappingURL=sessionAgentTransition.d.ts.map

package/node_modules/@happier-dev/protocol/dist/sessionAgentTransition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionAgentTransition.d.ts","sourceRoot":"","sources":["../src/sessionAgentTransition.ts"],"names":[],"mappings":"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"}