@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

package/packages/shared/dist/protocol-schemas.js

@@ -17,6 +17,13 @@ const agentProfileSchema = z.object({
     label: z.string().min(1),
     command: z.string().min(1).optional(),
     historyModel: z.enum(["append-only", "authoritative-linear"]).optional(),
+    defaultModel: z.string().min(1).optional(),
+    models: z.array(z.object({
+        id: z.string().min(1),
+        label: z.string().min(1).optional(),
+        unavailable: z.boolean().optional(),
+        reason: z.string().min(1).optional(),
+    })).optional(),
     sessionPrimitives: z.object({
         resume: z.enum(["acpx", "native", "checkpoint", "unsupported"]),
         rewind: z.enum(["acpx", "native", "checkpoint", "unsupported"]),
@@ -68,6 +75,12 @@ export const sessionSnapshotSchema = z.object({
     encryptedMetadata: encryptedEnvelopeSchema.optional(),
     currentHead: z.string().min(1).optional(),
     lastTurnId: z.string().min(1).optional(),
+    headBasis: z.object({
+        eventId: z.number().int().nonnegative().optional(),
+        messageId: z.string().min(1).optional(),
+        logicalTime: z.number().optional(),
+        turnSeq: z.number().int().nonnegative().optional(),
+    }).optional(),
     sourceSessionId: z.string().min(1).optional(),
     sourceCheckpointId: z.string().min(1).optional(),
     historyModel: z.enum(["append-only", "authoritative-linear"]).optional(),
@@ -177,4 +190,264 @@ export const machineDevExecResultSchema = z.object({
     durationMs: z.number().nonnegative(),
     timedOut: z.boolean().optional(),
 });
+export const turnReconcileResultSchema = z.object({
+    sessionId: z.string().min(1),
+    turnId: z.string().min(1).optional(),
+    requestId: z.string().min(1).optional(),
+    status: z.enum(["active", "terminal", "unknown", "not_found", "uninspectable"]),
+    terminalStatus: z.enum(["completed", "cancelled", "failed"]).optional(),
+    currentHead: z.string().min(1).optional(),
+    lastTurnId: z.string().min(1).optional(),
+    providerTurnId: z.string().min(1).optional(),
+    reason: z.string().optional(),
+    error: z.string().optional(),
+    evidence: z.object({
+        type: z.enum(["in_memory", "provider_history", "provider_inspect", "unsupported", "missing"]),
+        detail: z.string().optional(),
+    }).optional(),
+});
+const gatewayLastDeliveredMessageSchema = z.object({
+    externalConversationId: z.string().min(1),
+    externalMessageId: z.string().min(1),
+    requestId: z.string().min(1),
+    sessionId: z.string().min(1),
+    turnId: z.string().min(1),
+    deliveredAt: z.string().min(1),
+});
+const gatewayLastMessageRefSchema = z.object({
+    externalConversationId: z.string().min(1),
+    externalMessageId: z.string().min(1),
+    requestId: z.string().min(1).optional(),
+    sessionId: z.string().min(1).optional(),
+    turnId: z.string().min(1).optional(),
+    deliveryId: z.string().min(1).optional(),
+    platformMessageId: z.string().min(1).optional(),
+    at: z.string().min(1),
+});
+const gatewayProcessingReactionConfigSchema = z.object({
+    enabled: z.boolean(),
+    emojiType: z.string().min(1),
+});
+export const gatewayChannelPublicSchema = z.object({
+    id: z.string().min(1),
+    type: z.enum(["fake", "lark"]),
+    enabled: z.boolean(),
+    domain: z.enum(["feishu", "lark"]).optional(),
+    inboundMode: z.enum(["mention", "all"]).optional(),
+    processingReaction: gatewayProcessingReactionConfigSchema.optional(),
+    targetMachineId: z.string().min(1).optional(),
+    targetSessionId: z.string().min(1).optional(),
+    targetCwd: z.string().optional(),
+    defaultAgent: z.string().min(1),
+    defaultModel: z.string().min(1).optional(),
+    allowAnySender: z.boolean().optional(),
+    allowedChatIds: z.array(z.string().min(1)).optional(),
+    allowedSenderIds: z.array(z.string().min(1)).optional(),
+    hasAppId: z.boolean(),
+    hasAppSecret: z.boolean(),
+    hasLocalToken: z.boolean().optional(),
+    hasLocalSecret: z.boolean().optional(),
+    listening: z.boolean().optional(),
+    lastError: z.string().optional(),
+    lastReceived: gatewayLastMessageRefSchema.optional(),
+    lastAdmitted: gatewayLastMessageRefSchema.optional(),
+    lastReplied: gatewayLastMessageRefSchema.optional(),
+    lastDeliveredMessage: gatewayLastDeliveredMessageSchema.optional(),
+    createdAt: z.string().min(1),
+    updatedAt: z.string().min(1),
+});
+export const gatewayChannelInputSchema = z.object({
+    id: z.string().min(1).optional(),
+    type: z.enum(["fake", "lark"]),
+    enabled: z.boolean().optional(),
+    targetMachineId: z.string().min(1).optional(),
+    targetSessionId: z.string().min(1).optional(),
+    targetCwd: z.string().optional(),
+    defaultAgent: z.string().min(1).optional(),
+    defaultModel: z.string().min(1).optional(),
+    allowAnySender: z.boolean().optional(),
+    allowedChatIds: z.array(z.string().min(1)).optional(),
+    allowedSenderIds: z.array(z.string().min(1)).optional(),
+    domain: z.enum(["feishu", "lark"]).optional(),
+    appId: z.string().min(1).optional(),
+    appSecret: z.string().min(1).optional(),
+    encryptedAppSecret: encryptedEnvelopeSchema.optional(),
+    inboundMode: z.enum(["mention", "all"]).optional(),
+    processingReaction: gatewayProcessingReactionConfigSchema.partial().optional(),
+    localToken: z.string().min(1).optional(),
+    localSecret: z.string().min(1).optional(),
+});
+export const gatewayDeliveryResultSchema = z.object({
+    channelId: z.string().min(1),
+    externalConversationId: z.string().min(1),
+    externalMessageId: z.string().min(1),
+    sessionId: z.string().min(1).optional(),
+    requestId: z.string().min(1).optional(),
+    turnId: z.string().min(1).optional(),
+    deliveryId: z.string().min(1).optional(),
+    platformMessageId: z.string().min(1).optional(),
+    admission: z.enum(["accepted", "replayed"]).optional(),
+    dispatch: z.enum(["queued", "delivered"]).optional(),
+    queued: z.boolean().optional(),
+    duplicate: z.boolean().optional(),
+});
+export const gatewayCommandResultSchema = z.object({
+    action: z.enum(["list", "get", "upsert", "enable", "disable", "test", "notify"]),
+    channels: z.array(gatewayChannelPublicSchema).optional(),
+    channel: gatewayChannelPublicSchema.optional(),
+    delivery: gatewayDeliveryResultSchema.optional(),
+});
+export const scheduleSpecSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("manual") }),
+    z.object({ type: z.literal("oneshot"), runAt: z.string().min(1) }),
+    z.object({ type: z.literal("interval"), everyMs: z.number().positive() }),
+    z.object({ type: z.literal("cron"), expr: z.string().min(1), timezone: z.string().min(1).optional() }),
+]);
+export const scheduleTargetSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("sourceSession"), sourceSessionId: z.string().min(1) }),
+    z.object({
+        type: z.literal("project"),
+        machineId: z.string().min(1).optional(),
+        cwd: z.string().min(1),
+        agent: z.string().min(1),
+        sourceSessionId: z.string().min(1).optional(),
+    }),
+]);
+const scheduleExecutionSchema = z.enum(["continue", "isolated"]);
+const scheduleMemoryModeSchema = z.enum(["inherit", "off", "readonly", "readwrite"]);
+const scheduleStopReasonSchema = z.enum(["blocked", "failed", "permission"]);
+export const scheduleRunRecordSchema = z.object({
+    occurrenceId: z.string().min(1),
+    dueAt: z.string().min(1),
+    requestId: z.string().min(1),
+    turnId: z.string().min(1),
+    status: z.enum(["scheduled", "admitted", "missed", "blocked", "paused", "deleted", "failed", "completed"]),
+    reason: z.string().optional(),
+    sessionId: z.string().min(1).optional(),
+    sourceSessionId: z.string().min(1).optional(),
+    admittedAt: z.string().min(1).optional(),
+    finishedAt: z.string().min(1).optional(),
+    outputPreview: z.string().optional(),
+    error: z.string().optional(),
+});
+export const scheduleRecordSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1).optional(),
+    sessionId: z.string().min(1).optional(),
+    sourceSessionId: z.string().min(1).optional(),
+    target: scheduleTargetSchema.optional(),
+    prompt: z.string(),
+    dueAt: z.string().min(1).optional(),
+    schedule: scheduleSpecSchema.optional(),
+    execution: scheduleExecutionSchema.optional(),
+    memoryMode: scheduleMemoryModeSchema.optional(),
+    stopOn: z.array(scheduleStopReasonSchema).optional(),
+    status: z.enum(["active", "paused", "completed", "deleted"]),
+    nextRunAt: z.string().min(1).optional(),
+    previewRunAt: z.array(z.string().min(1)).optional(),
+    pendingRunId: z.string().min(1).optional(),
+    runCount: z.number().int().nonnegative().optional(),
+    lastRun: scheduleRunRecordSchema.optional(),
+    createdAt: z.string().min(1),
+    updatedAt: z.string().min(1),
+    runs: z.array(scheduleRunRecordSchema),
+});
+export const scheduleCreateInputSchema = z.object({
+    id: z.string().min(1).optional(),
+    name: z.string().min(1).optional(),
+    sessionId: z.string().min(1).optional(),
+    sourceSessionId: z.string().min(1).optional(),
+    target: scheduleTargetSchema.optional(),
+    prompt: z.string().min(1),
+    dueAt: z.string().min(1).optional(),
+    schedule: scheduleSpecSchema.optional(),
+    execution: scheduleExecutionSchema.optional(),
+    memoryMode: scheduleMemoryModeSchema.optional(),
+    stopOn: z.array(scheduleStopReasonSchema).optional(),
+});
+export const scheduleCommandResultSchema = z.object({
+    action: z.enum(["list", "show", "create", "pause", "resume", "delete", "history", "run", "runDue", "runMissed"]),
+    schedules: z.array(scheduleRecordSchema).optional(),
+    schedule: scheduleRecordSchema.optional(),
+    scheduleId: z.string().min(1).optional(),
+    history: z.array(scheduleRunRecordSchema).optional(),
+    runs: z.array(z.object({
+        scheduleId: z.string().min(1),
+        run: scheduleRunRecordSchema,
+    })).optional(),
+    run: scheduleRunRecordSchema.optional(),
+});
+const memoryLayerSchema = z.enum(["user", "curated", "daily"]);
+const memoryModeSchema = z.enum(["off", "readonly", "readwrite"]);
+export const memoryCitationSchema = z.object({
+    path: z.string().min(1),
+    startLine: z.number().int().min(1),
+    endLine: z.number().int().min(1),
+    contentHash: z.string().min(1).optional(),
+    stale: z.boolean().optional(),
+});
+export const memoryFileSummarySchema = z.object({
+    path: z.string().min(1),
+    layer: memoryLayerSchema,
+    updatedAt: z.string().min(1),
+    lineCount: z.number().int().nonnegative(),
+    byteSize: z.number().int().nonnegative(),
+    contentHash: z.string().min(1),
+});
+export const memorySearchResultSchema = z.object({
+    id: z.string().min(1),
+    layer: memoryLayerSchema,
+    path: z.string().min(1),
+    title: z.string().min(1).optional(),
+    snippet: z.string(),
+    citation: memoryCitationSchema,
+    score: z.number(),
+    updatedAt: z.string().min(1),
+});
+export const memoryOverviewSchema = z.object({
+    projectKey: z.string().min(1),
+    mode: memoryModeSchema,
+    root: z.string().min(1),
+    files: z.array(memoryFileSummarySchema),
+    updatedAt: z.string().min(1),
+});
+export const memoryWriteInputSchema = z.object({
+    projectKey: z.string().min(1),
+    layer: memoryLayerSchema,
+    text: z.string().min(1),
+    title: z.string().min(1).optional(),
+    date: z.string().min(1).optional(),
+});
+export const memoryPromoteInputSchema = z.object({
+    projectKey: z.string().min(1),
+    source: memoryCitationSchema,
+    targetLayer: z.enum(["user", "curated"]),
+    title: z.string().min(1).optional(),
+});
+export const memorySyncConflictSchema = z.object({
+    path: z.string().min(1),
+    layer: memoryLayerSchema,
+    localContentHash: z.string().min(1).optional(),
+    remoteContentHash: z.string().min(1).optional(),
+    mergedContentHash: z.string().min(1),
+});
+export const memoryTurnOptionsSchema = z.object({
+    mode: memoryModeSchema,
+    projectKey: z.string().min(1),
+    topN: z.number().int().positive().optional(),
+});
+export const memoryCommandResultSchema = z.object({
+    action: z.enum(["overview", "read", "search", "reindex", "write", "promote", "status", "sync"]),
+    overview: memoryOverviewSchema.optional(),
+    path: z.string().min(1).optional(),
+    layer: memoryLayerSchema.optional(),
+    content: z.string().optional(),
+    citations: z.array(memoryCitationSchema).optional(),
+    results: z.array(memorySearchResultSchema).optional(),
+    written: memoryFileSummarySchema.optional(),
+    promoted: memoryFileSummarySchema.optional(),
+    conflicts: z.array(memorySyncConflictSchema).optional(),
+    mode: memoryModeSchema.optional(),
+    syncedAt: z.string().min(1).optional(),
+});
 //# sourceMappingURL=protocol-schemas.js.map

package/packages/shared/dist/protocol-types.d.ts

@@ -4,6 +4,13 @@ export type AgentProfile = {
     label: string;
     command?: string;
     historyModel?: "append-only" | "authoritative-linear";
+    defaultModel?: string;
+    models?: Array<{
+        id: string;
+        label?: string;
+        unavailable?: boolean;
+        reason?: string;
+    }>;
     sessionPrimitives?: {
         resume: "acpx" | "native" | "checkpoint" | "unsupported";
         rewind: "acpx" | "native" | "checkpoint" | "unsupported";
@@ -12,6 +19,7 @@ export type AgentProfile = {
     };
 };
 export type PermissionMode = "approve-all" | "approve-reads" | "deny-all";
+export type MemoryMode = "off" | "readonly" | "readwrite";
 export type MachineSnapshot = {
     id: string;
     name: string;
@@ -45,6 +53,12 @@ export type SessionSnapshot = {
     encryptedMetadata?: EncryptedEnvelope;
     currentHead?: string;
     lastTurnId?: string;
+    headBasis?: {
+        eventId?: number;
+        messageId?: string;
+        logicalTime?: number;
+        turnSeq?: number;
+    };
     sourceSessionId?: string;
     sourceCheckpointId?: string;
     historyModel?: "append-only" | "authoritative-linear";
@@ -153,6 +167,309 @@ export type MachineDevExecResult = {
     durationMs: number;
     timedOut?: boolean;
 };
+export type TurnInspectionStatus = "active" | "terminal" | "unknown" | "not_found" | "uninspectable";
+export type TurnReconcileResult = {
+    sessionId: string;
+    turnId?: string;
+    requestId?: string;
+    status: TurnInspectionStatus;
+    terminalStatus?: "completed" | "cancelled" | "failed";
+    currentHead?: string;
+    lastTurnId?: string;
+    providerTurnId?: string;
+    reason?: string;
+    error?: string;
+    evidence?: {
+        type: "in_memory" | "provider_history" | "provider_inspect" | "unsupported" | "missing";
+        detail?: string;
+    };
+};
+export type GatewayChannelType = "fake" | "lark";
+export type GatewayChannelDomain = "feishu" | "lark";
+export type GatewayInboundMode = "mention" | "all";
+export type GatewayProcessingReactionConfig = {
+    enabled: boolean;
+    emojiType: string;
+};
+export type GatewayConversationKey = {
+    platformChatId: string;
+    contextKind: "main";
+    contextKey?: never;
+} | {
+    platformChatId: string;
+    contextKind: "thread";
+    contextKey: string;
+};
+export type GatewayDestination = GatewayConversationKey & {
+    replyToMessageId?: string;
+};
+export type GatewayLastDeliveredMessage = {
+    externalConversationId: string;
+    externalMessageId: string;
+    requestId: string;
+    sessionId: string;
+    turnId: string;
+    deliveredAt: string;
+};
+export type GatewayLastMessageRef = {
+    externalConversationId: string;
+    externalMessageId: string;
+    requestId?: string;
+    sessionId?: string;
+    turnId?: string;
+    deliveryId?: string;
+    platformMessageId?: string;
+    at: string;
+};
+export type GatewayActionHint = {
+    label: string;
+    prompt?: string;
+};
+export type GatewayEventPayload = {
+    type: "turn_stopped";
+    sessionId: string;
+    machineId: string;
+    turnId: string;
+    status: "completed" | "cancelled" | "failed" | "blocked" | "needs_user";
+    stopReason?: string;
+    error?: string;
+    outputPreview?: string;
+    sessionName?: string;
+    actionHints?: GatewayActionHint[];
+} | {
+    type: "notice";
+    title: string;
+    text: string;
+    severity?: "info" | "warning" | "error";
+};
+export type GatewayChannelPublic = {
+    id: string;
+    type: GatewayChannelType;
+    enabled: boolean;
+    domain?: GatewayChannelDomain;
+    inboundMode?: GatewayInboundMode;
+    processingReaction?: GatewayProcessingReactionConfig;
+    targetMachineId?: string;
+    targetSessionId?: string;
+    targetCwd?: string;
+    defaultAgent: string;
+    defaultModel?: string;
+    allowAnySender?: boolean;
+    allowedChatIds?: string[];
+    allowedSenderIds?: string[];
+    hasAppId: boolean;
+    hasAppSecret: boolean;
+    hasLocalToken?: boolean;
+    hasLocalSecret?: boolean;
+    listening?: boolean;
+    lastError?: string;
+    lastReceived?: GatewayLastMessageRef;
+    lastAdmitted?: GatewayLastMessageRef;
+    lastReplied?: GatewayLastMessageRef;
+    lastDeliveredMessage?: GatewayLastDeliveredMessage;
+    createdAt: string;
+    updatedAt: string;
+};
+export type GatewayChannelInput = {
+    id?: string;
+    type: GatewayChannelType;
+    enabled?: boolean;
+    targetMachineId?: string;
+    targetSessionId?: string;
+    targetCwd?: string;
+    defaultAgent?: string;
+    defaultModel?: string;
+    allowAnySender?: boolean;
+    allowedChatIds?: string[];
+    allowedSenderIds?: string[];
+    domain?: GatewayChannelDomain;
+    appId?: string;
+    appSecret?: string;
+    encryptedAppSecret?: EncryptedEnvelope;
+    inboundMode?: GatewayInboundMode;
+    processingReaction?: Partial<GatewayProcessingReactionConfig>;
+    localToken?: string;
+    localSecret?: string;
+};
+export type GatewayDeliveryResult = {
+    channelId: string;
+    externalConversationId: string;
+    externalMessageId: string;
+    sessionId?: string;
+    requestId?: string;
+    turnId?: string;
+    deliveryId?: string;
+    platformMessageId?: string;
+    admission?: "accepted" | "replayed";
+    dispatch?: "queued" | "delivered";
+    queued?: boolean;
+    duplicate?: boolean;
+};
+export type GatewayCommandResult = {
+    action: "list" | "get" | "upsert" | "enable" | "disable" | "test" | "notify";
+    channels?: GatewayChannelPublic[];
+    channel?: GatewayChannelPublic;
+    delivery?: GatewayDeliveryResult;
+};
+export type ScheduleSpec = {
+    type: "manual";
+} | {
+    type: "oneshot";
+    runAt: string;
+} | {
+    type: "interval";
+    everyMs: number;
+} | {
+    type: "cron";
+    expr: string;
+    timezone?: string;
+};
+export type ScheduleTarget = {
+    type: "sourceSession";
+    sourceSessionId: string;
+} | {
+    type: "project";
+    machineId?: string;
+    cwd: string;
+    agent: string;
+    sourceSessionId?: string;
+};
+export type ScheduleExecution = "continue" | "isolated";
+export type ScheduleMemoryMode = "inherit" | "off" | "readonly" | "readwrite";
+export type ScheduleStopReason = "blocked" | "failed" | "permission";
+export type ScheduleRunRecord = {
+    occurrenceId: string;
+    dueAt: string;
+    requestId: string;
+    turnId: string;
+    status: "scheduled" | "admitted" | "missed" | "blocked" | "paused" | "deleted" | "failed" | "completed";
+    reason?: string;
+    sessionId?: string;
+    sourceSessionId?: string;
+    admittedAt?: string;
+    finishedAt?: string;
+    outputPreview?: string;
+    error?: string;
+};
+export type ScheduleRecord = {
+    id: string;
+    name?: string;
+    sessionId?: string;
+    sourceSessionId?: string;
+    target?: ScheduleTarget;
+    prompt: string;
+    dueAt?: string;
+    schedule?: ScheduleSpec;
+    execution?: ScheduleExecution;
+    memoryMode?: ScheduleMemoryMode;
+    stopOn?: ScheduleStopReason[];
+    status: "active" | "paused" | "completed" | "deleted";
+    nextRunAt?: string;
+    previewRunAt?: string[];
+    pendingRunId?: string;
+    runCount?: number;
+    lastRun?: ScheduleRunRecord;
+    createdAt: string;
+    updatedAt: string;
+    runs: ScheduleRunRecord[];
+};
+export type ScheduleCreateInput = {
+    id?: string;
+    name?: string;
+    sessionId?: string;
+    sourceSessionId?: string;
+    target?: ScheduleTarget;
+    prompt: string;
+    dueAt?: string;
+    schedule?: ScheduleSpec;
+    execution?: ScheduleExecution;
+    memoryMode?: ScheduleMemoryMode;
+    stopOn?: ScheduleStopReason[];
+};
+export type ScheduleCommandResult = {
+    action: "list" | "show" | "create" | "pause" | "resume" | "delete" | "history" | "run" | "runDue" | "runMissed";
+    schedules?: ScheduleRecord[];
+    schedule?: ScheduleRecord;
+    scheduleId?: string;
+    history?: ScheduleRunRecord[];
+    runs?: Array<{
+        scheduleId: string;
+        run: ScheduleRunRecord;
+    }>;
+    run?: ScheduleRunRecord;
+};
+export type MemoryLayer = "user" | "curated" | "daily";
+export type MemoryCitation = {
+    path: string;
+    startLine: number;
+    endLine: number;
+    contentHash?: string;
+    stale?: boolean;
+};
+export type MemoryFileSummary = {
+    path: string;
+    layer: MemoryLayer;
+    updatedAt: string;
+    lineCount: number;
+    byteSize: number;
+    contentHash: string;
+};
+export type MemorySearchResult = {
+    id: string;
+    layer: MemoryLayer;
+    path: string;
+    title?: string;
+    snippet: string;
+    citation: MemoryCitation;
+    score: number;
+    updatedAt: string;
+};
+export type MemoryPromoteInput = {
+    projectKey: string;
+    source: MemoryCitation;
+    targetLayer: "user" | "curated";
+    title?: string;
+};
+export type MemorySyncConflict = {
+    path: string;
+    layer: MemoryLayer;
+    localContentHash?: string;
+    remoteContentHash?: string;
+    mergedContentHash: string;
+};
+export type MemoryOverview = {
+    projectKey: string;
+    mode: MemoryMode;
+    root: string;
+    files: MemoryFileSummary[];
+    updatedAt: string;
+};
+export type MemoryWriteInput = {
+    projectKey: string;
+    layer: MemoryLayer;
+    text: string;
+    title?: string;
+    date?: string;
+};
+export type MemoryCommandResult = {
+    action: "overview" | "read" | "search" | "reindex" | "write" | "promote" | "status" | "sync";
+    overview?: MemoryOverview;
+    path?: string;
+    layer?: MemoryLayer;
+    content?: string;
+    citations?: MemoryCitation[];
+    results?: MemorySearchResult[];
+    written?: MemoryFileSummary;
+    promoted?: MemoryFileSummary;
+    conflicts?: MemorySyncConflict[];
+    mode?: MemoryMode;
+    syncedAt?: string;
+};
+export type MemoryTurnOptions = {
+    mode: MemoryMode;
+    projectKey: string;
+    topN?: number;
+};
 export type EncryptedSessionEvent = {
     id: number;
     sessionId: string;
@@ -172,17 +489,68 @@ export type EncryptedTranscriptReplacementEvent = {
     occurredAt?: number;
     payload: EncryptedEnvelope;
 };
-export type TranscriptWindowState = {
-    hasMoreBefore?: boolean;
-    nextBefore?: string;
+export type SessionHeadAdvanceBasis = {
+    turnId: string;
+    eventMessageId: string;
+    turnSeq: number;
+    occurredAt?: number;
+};
+export type SessionUsageSnapshot = {
+    source: "provider" | "estimated";
+    usedTokens: number;
+    contextWindowTokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    reasoningOutputTokens?: number;
+    totalTokens?: number;
+};
+export type PromptAttachment = {
+    id: string;
+    name: string;
+    mediaType: string;
+    sizeBytes: number;
+    data: string;
+};
+export type OptionChoice = {
+    id: string;
+    label: string;
+    description?: string;
 };
 export type SessionEventPayload = {
     type: "user_prompt";
     text: string;
+    attachments?: PromptAttachment[];
+} | {
+    type: "option_request";
+    optionRequestId: string;
+    title?: string;
+    message: string;
+    options: OptionChoice[];
+    allowFreeText?: boolean;
+} | {
+    type: "option_response";
+    optionRequestId: string;
+    selectedOptionId?: string;
+    text?: string;
 } | {
     type: "status";
     text: string;
     tag?: string;
+} | {
+    type: "memory_used";
+    mode: MemoryMode;
+    projectKey: string;
+    memories: Array<{
+        id: string;
+        layer: MemoryLayer;
+        path: string;
+        title?: string;
+        citation: MemoryCitation;
+    }>;
+} | {
+    type: "session_usage";
+    usage: SessionUsageSnapshot;
 } | {
     type: "text_delta";
     text: string;