@murphai/murph 1.3.1 → 1.3.2

package/node_modules/@murphai/assistant-engine/dist/assistant-codex/dynamic-tools.js

@@ -4,7 +4,7 @@ import { hostedRuntimeAssistantPersonalizationModelToolRequestSchema, } from '@m
 import { HOSTED_EXECUTION_ASSISTANT_ASK_QUESTION_MAX_CODE_POINTS, HOSTED_EXECUTION_ASSISTANT_ASK_TARGET_LABEL_MAX_CODE_POINTS, HOSTED_EXECUTION_DAILY_METRIC_MAX_UNIT_LENGTH, } from '@murphai/hosted-execution/contracts';
 import { HOSTED_EXECUTION_MEMBER_REPORTED_DAILY_METRIC_KEYS, } from '@murphai/hosted-execution';
 import { hostedRuntimePendingGroupSetupInputSchema, } from '@murphai/hosted-execution/pending-group-setup';
-import { HOSTED_FAMILY_PLAN_CODES, HOSTED_PRODUCT_FEEDBACK_KINDS, HOSTED_PRODUCT_FEEDBACK_SUMMARY_MAX_LENGTH, HOSTED_PRODUCT_SUPPORT_ESCALATION_PREFIX, isHostedProductSupportEscalationFeedback, HOSTED_RUNTIME_ASSISTANT_ASK_REQUEST_ID_MAX_CODE_POINTS, HOSTED_RUNTIME_GROUP_DISCLOSURE_PERMISSION_TEXT_MAX_CODE_POINTS, HOSTED_RUNTIME_GROUP_DISPLAY_NAME_MAX_LENGTH, HOSTED_RUNTIME_GROUP_JOIN_OFFER_LEGACY_MESSAGE_TEMPLATE, HOSTED_RUNTIME_GROUP_EMAIL_HTML_MAX_LENGTH, HOSTED_RUNTIME_GROUP_EMAIL_SUBJECT_MAX_LENGTH, HOSTED_RUNTIME_GROUP_EMAIL_TEXT_MAX_LENGTH, HOSTED_USAGE_REFERRAL_POLICY_CODES, isHostedRuntimeAssistantAskDiagnosticCode, isHostedRuntimeAssistantAskRequestId, sanitizeHostedProductFeedbackSummary, } from '@murphai/hosted-execution/runtime-control';
+import { HOSTED_FAMILY_PLAN_CODES, HOSTED_PRODUCT_FEEDBACK_KINDS, HOSTED_PRODUCT_FEEDBACK_SUMMARY_MAX_LENGTH, HOSTED_PRODUCT_SUPPORT_ESCALATION_PREFIX, isHostedProductSupportEscalationFeedback, HOSTED_RUNTIME_ASSISTANT_ASK_REQUEST_ID_MAX_CODE_POINTS, HOSTED_RUNTIME_GROUP_CONTEXT_HANDOFF_MAX_CODE_POINTS, HOSTED_RUNTIME_GROUP_DISCLOSURE_PERMISSION_TEXT_MAX_CODE_POINTS, HOSTED_RUNTIME_GROUP_DISPLAY_NAME_MAX_LENGTH, HOSTED_RUNTIME_GROUP_JOIN_OFFER_LEGACY_MESSAGE_TEMPLATE, HOSTED_RUNTIME_GROUP_EMAIL_HTML_MAX_LENGTH, HOSTED_RUNTIME_GROUP_EMAIL_SUBJECT_MAX_LENGTH, HOSTED_RUNTIME_GROUP_EMAIL_TEXT_MAX_LENGTH, HOSTED_USAGE_REFERRAL_POLICY_CODES, isHostedRuntimeAssistantAskDiagnosticCode, isHostedRuntimeAssistantAskRequestId, sanitizeHostedProductFeedbackSummary, } from '@murphai/hosted-execution/runtime-control';
 import { HOSTED_ASSISTANT_PRODUCT_MODELS, HOSTED_ASSISTANT_PROVIDERS, HOSTED_ASSISTANT_REASONING_EFFORTS, } from '@murphai/hosted-execution/assistant-model';
 import { HOSTED_GROUP_MEMBER_PLAN_DISPLAY_NAME, HOSTED_PLAN_USAGE_DIRECT_BILLING_PLAN_CODES, } from '@murphai/hosted-execution/plan-usage';
 import { hostedRuntimeSubscriptionToolRequestSchema, } from '@murphai/hosted-execution/subscription';
@@ -38,16 +38,17 @@ import { executeDeviceDynamicTool, readDeviceDynamicToolRequest, } from './dynam
 import { executeLabsDynamicTool, readLabsDynamicToolRequest, } from './dynamic-tools/labs.js';
 import { executePendingVaultFilesDynamicTool, readPendingVaultFilesDynamicToolRequest, } from './dynamic-tools/pending-vault-files.js';
 import { executeGroupRoomModelDynamicTool, readGroupRoomModelDynamicToolRequest, } from './dynamic-tools/group-room-model.js';
+import { executeMemberMemoryDynamicTool, readMemberMemoryDynamicToolRequest, } from './dynamic-tools/member-memory.js';
 import { readClinicalRecordsConnectLinkDynamicToolRequest, } from './dynamic-tools/clinical-records.js';
 import { executeConnectedAppsDynamicTool, readConnectedAppsDynamicToolRequest, } from './dynamic-tools/connected-apps.js';
 import { executeGenerateVoiceMemoDynamicTool, MURPH_GENERATE_VOICE_MEMO_TOOL, parseGenerateVoiceMemoArguments, } from './dynamic-tools/generate-voice-memo.js';
 import { createPhoneCallRequestKey, createScheduledPhoneCallRequestKey, normalizePhoneCallBriefForConversationScope, readPhoneCallDynamicToolRequest, } from './dynamic-tools/phone-calls.js';
 import { buildPhysicalNoteFailureInstruction, createPhysicalNoteRequestKey, readPhysicalNoteDynamicToolRequest, resolvePhysicalNoteExplicitOriginInputId, } from './dynamic-tools/physical-notes.js';
-import { buildResponseCardValidationFeedback, } from './response-card-validation-feedback.js';
 import { executeGenerateSongDynamicTool, MURPH_GENERATE_SONG_TOOL, parseGenerateSongArguments, } from './dynamic-tools/generate-song.js';
 import { executeAskGrokDynamicTool, MURPH_ASK_GROK_TOOL, parseAskGrokArguments, } from './dynamic-tools/ask-grok.js';
+import { executeAnalyzeVideoDynamicTool, MURPH_ANALYZE_VIDEO_TOOL, parseAnalyzeVideoArguments, } from './dynamic-tools/analyze-video.js';
 export * from './dynamic-tool-catalog.js';
-import { asRecord, ASSISTANT_ACCEPTED_MESSAGE_REF_PATTERN, GENERATE_IMAGE_REFERENCE_IMAGE_REFS_DESCRIPTION, GROUP_ACCESS_FRESH_NATIVE_RESPONSE_HANDLING, HOSTED_COMPUTER_UNKNOWN_OUTCOME_TEXT, MURPH_ASSISTANT_CONFIGURATION_TOOL, MURPH_ATTACH_EXERCISE_ROUTINE_CARD_TOOL, MURPH_ATTACH_RESPONSE_CARD_TOOL, MURPH_ATTACH_TELEGRAM_RICH_CONTENT_TOOL, MURPH_ATTACH_RESPONSE_MEDIA_TOOL, MURPH_COMPUTER_ACT_TOOL, MURPH_COMPUTER_FINISH_RUN_TOOL, MURPH_COMPUTER_OPEN_TOOL, MURPH_COMPUTER_OS_CONTROL_TOOL, MURPH_COMPUTER_PAUSE_FOR_USER_TOOL, MURPH_FAMILY_PLAN_TOOL, MURPH_FINISH_WITHOUT_REPLY_TOOL, MURPH_GENERATE_IMAGE_TOOL, MURPH_GROUP_TOOL, MURPH_IMESSAGE_CONTACT_TOOL, MURPH_PERSONALIZATION_TOOL, MURPH_PLAN_USAGE_TOOL, MURPH_REACT_TO_MESSAGE_TOOL, MURPH_SELECT_REPLY_TARGET_TOOL, MURPH_SEND_PROGRESS_UPDATE_TOOL, MURPH_SEND_VAULT_FILE_TOOL, MURPH_SUBMIT_PRODUCT_FEEDBACK_TOOL, MURPH_SUBSCRIPTION_TOOL, } from './dynamic-tool-catalog.js';
+import { asRecord, ASSISTANT_ACCEPTED_MESSAGE_REF_PATTERN, GENERATE_IMAGE_REFERENCE_IMAGE_REFS_DESCRIPTION, GROUP_ACCESS_FRESH_NATIVE_RESPONSE_HANDLING, HOSTED_COMPUTER_UNKNOWN_OUTCOME_TEXT, MURPH_ASSISTANT_CONFIGURATION_TOOL, MURPH_ATTACH_EXERCISE_ROUTINE_CARD_TOOL, MURPH_ATTACH_RESPONSE_CARD_TOOL, MURPH_ATTACH_TELEGRAM_RICH_CONTENT_TOOL, MURPH_ATTACH_RESPONSE_MEDIA_TOOL, MURPH_COMPUTER_ACT_TOOL, MURPH_COMPUTER_FINISH_RUN_TOOL, MURPH_COMPUTER_OPEN_TOOL, MURPH_COMPUTER_OS_CONTROL_TOOL, MURPH_COMPUTER_PAUSE_FOR_USER_TOOL, MURPH_FAMILY_PLAN_TOOL, MURPH_FINISH_WITHOUT_REPLY_TOOL, MURPH_GENERATE_IMAGE_TOOL, MURPH_GROUP_TOOL_FAMILY_ACTIONS, MURPH_GROUP_TOOL_NAME, MURPH_GROUP_TOOL_ROOT_KEYS_BY_NAME, MURPH_IMESSAGE_CONTACT_TOOL, MURPH_PERSONALIZATION_TOOL, MURPH_PLAN_USAGE_TOOL, MURPH_REACT_TO_MESSAGE_TOOL, MURPH_SELECT_REPLY_TARGET_TOOL, MURPH_SEND_PROGRESS_UPDATE_TOOL, MURPH_SEND_VAULT_FILE_TOOL, MURPH_SUBMIT_PRODUCT_FEEDBACK_TOOL, MURPH_SUBSCRIPTION_TOOL, } from './dynamic-tool-catalog.js';
 const CODEX_DYNAMIC_TOOL_CALL_METHOD = 'item/tool/call';
 function addAttachResponseCardArgumentIssues(value, context) {
     if (value.card.kind === 'compact_table' &&
@@ -158,6 +159,18 @@ const groupVaultShareProjectionScopeSchema = z.unknown().transform((value, conte
     }
     return scope;
 });
+const groupLabelSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .refine((value) => Array.from(value).length
+    <= HOSTED_EXECUTION_ASSISTANT_ASK_TARGET_LABEL_MAX_CODE_POINTS, { message: 'groupLabel exceeds the Unicode code-point limit' });
+const groupHandoffContextSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .refine((value) => Array.from(value).length
+    <= HOSTED_RUNTIME_GROUP_CONTEXT_HANDOFF_MAX_CODE_POINTS, { message: 'context exceeds the Unicode code-point limit' });
 const groupQuestionSchema = z
     .string()
     .trim()
@@ -174,16 +187,17 @@ const groupArgumentsSchema = z.discriminatedUnion('action', [
     z
         .object({
         action: z.literal('ask'),
-        groupLabel: z
-            .string()
-            .trim()
-            .min(1)
-            .refine((value) => Array.from(value).length
-            <= HOSTED_EXECUTION_ASSISTANT_ASK_TARGET_LABEL_MAX_CODE_POINTS, { message: 'groupLabel exceeds the Unicode code-point limit' })
-            .optional(),
+        groupLabel: groupLabelSchema.optional(),
         question: groupQuestionSchema,
     })
         .strict(),
+    z
+        .object({
+        action: z.literal('handoff'),
+        context: groupHandoffContextSchema,
+        groupLabel: groupLabelSchema.optional(),
+    })
+        .strict(),
     z
         .object({
         action: z.literal('ask_current_sender'),
@@ -399,6 +413,10 @@ const groupArgumentsSchema = z.discriminatedUnion('action', [
             .refine((projectionScopes) => new Set(projectionScopes.map(buildHostedVaultShareProjectionScopeKey)).size === projectionScopes.length, { message: 'projectionScopes must contain unique exact scopes' })
             .optional(),
         standaloneLink: z.boolean().optional(),
+        message_ref: z
+            .string()
+            .regex(new RegExp(ASSISTANT_ACCEPTED_MESSAGE_REF_PATTERN, 'u'))
+            .optional(),
     })
         .strict(),
     z
@@ -732,6 +750,13 @@ export function readMurphDynamicToolRequest(message, input) {
     if (groupRoomModelRequest) {
         return groupRoomModelRequest;
     }
+    const memberMemoryRequest = readMemberMemoryDynamicToolRequest({
+        arguments: request.arguments,
+        tool: request.tool,
+    });
+    if (memberMemoryRequest) {
+        return memberMemoryRequest;
+    }
     const connectedAppsRequest = readConnectedAppsDynamicToolRequest({
         arguments: request.arguments,
         tool: request.tool,
@@ -888,6 +913,19 @@ export function readMurphDynamicToolRequest(message, input) {
                 args: parsed.args,
             };
         }
+        case MURPH_ANALYZE_VIDEO_TOOL.name: {
+            const parsed = parseAnalyzeVideoArguments(request.arguments);
+            if (!parsed.ok) {
+                return {
+                    kind: 'invalid-analyze-video-arguments',
+                    validationDigest: parsed.validationDigest,
+                };
+            }
+            return {
+                kind: 'analyze-video',
+                args: parsed.args,
+            };
+        }
         case MURPH_ASK_GROK_TOOL.name: {
             const parsed = parseAskGrokArguments(request.arguments);
             if (!parsed.ok) {
@@ -1009,8 +1047,14 @@ export function readMurphDynamicToolRequest(message, input) {
                 request: parsed.request,
             };
         }
-        case MURPH_GROUP_TOOL.name: {
-            const parsed = parseGroupArguments(request.arguments);
+        case MURPH_GROUP_TOOL_NAME:
+        case 'group_consult':
+        case 'group_data':
+        case 'group_membership':
+        case 'group_usage':
+        case 'group_chat':
+        case 'group_email': {
+            const parsed = parseGroupArguments(request.arguments, request.tool);
             if (!parsed.ok) {
                 return {
                     kind: 'invalid-group-arguments',
@@ -1191,6 +1235,12 @@ export async function executeMurphDynamicToolRequest(input) {
         !canExecuteComputerDynamicTools(input.hostedToolContext ?? null)) {
         return toolTextResult(false, 'computer tools are unavailable without hosted computer-use transport');
     }
+    if ('validationDigest' in input.request
+        && input.request.kind !== 'invalid-automation-arguments') {
+        return invalidDynamicToolArgumentsResult(input.request.kind === 'invalid-progress-arguments'
+            ? 'invalid_progress_update_arguments'
+            : input.request.kind.replaceAll('-', '_'), input.request.validationDigest);
+    }
     switch (input.request.kind) {
         case 'invalid-automation-arguments': {
             switch (input.request.safeFailureCode) {
@@ -1212,54 +1262,6 @@ export async function executeMurphDynamicToolRequest(input) {
                     return invalidDynamicToolArgumentsResult('invalid_automation_arguments', input.request.validationDigest);
             }
         }
-        case 'invalid-device-arguments':
-            return toolTextResult(false, 'invalid device arguments');
-        case 'invalid-labs-arguments':
-            return toolTextResult(false, 'invalid labs arguments');
-        case 'invalid-pending-vault-files-arguments':
-            return toolTextResult(false, 'invalid pending vault-file arguments');
-        case 'invalid-group-room-model-arguments':
-            return toolTextResult(false, 'invalid group room-model arguments');
-        case 'invalid-connected-apps-arguments':
-            return toolTextResult(false, 'invalid connected-app arguments');
-        case 'invalid-assistant-style-arguments':
-            return toolTextResult(false, 'invalid assistant style arguments');
-        case 'invalid-generate-image-arguments':
-            return toolTextResult(false, 'invalid image generation arguments');
-        case 'invalid-computer-arguments':
-            return toolTextResult(false, 'invalid computer tool arguments');
-        case 'invalid-generate-voice-memo-arguments':
-            return invalidDynamicToolArgumentsResult('invalid_generate_voice_memo_arguments', input.request.validationDigest);
-        case 'invalid-generate-song-arguments':
-            return toolTextResult(false, 'invalid song generation arguments');
-        case 'invalid-ask-grok-arguments':
-            return toolTextResult(false, 'invalid ask_grok arguments');
-        case 'invalid-progress-arguments':
-            return toolTextResult(false, 'invalid progress update arguments');
-        case 'invalid-reaction-arguments':
-            return toolTextResult(false, 'invalid reaction arguments');
-        case 'invalid-reply-target-arguments':
-            return toolTextResult(false, 'invalid reply target arguments');
-        case 'invalid-product-feedback-arguments':
-            return toolTextResult(false, 'invalid product feedback arguments');
-        case 'invalid-family-plan-arguments':
-            return toolTextResult(false, 'invalid family plan arguments');
-        case 'invalid-personalization-arguments':
-            return toolTextResult(false, 'invalid personalization arguments');
-        case 'invalid-plan-usage-arguments':
-            return toolTextResult(false, 'invalid plan usage arguments');
-        case 'invalid-imessage-contact-arguments':
-            return toolTextResult(false, 'invalid iMessage contact arguments');
-        case 'invalid-subscription-arguments':
-            return toolTextResult(false, 'invalid subscription arguments');
-        case 'invalid-assistant-configuration-arguments':
-            return toolTextResult(false, 'invalid assistant configuration arguments');
-        case 'invalid-group-arguments':
-            return toolTextResult(false, 'invalid group arguments');
-        case 'invalid-finish-without-reply-arguments':
-            return toolTextResult(false, 'invalid no-reply arguments');
-        case 'invalid-response-card-arguments':
-            return toolTextResult(false, buildResponseCardValidationFeedback(input.request.validationDigest));
         case 'response-card-envelope-too-large':
             if (input.privateDirectResponseCardAllowed !== true) {
                 return toolTextResult(false, 'response cards require a private direct conversation');
@@ -1274,16 +1276,6 @@ export async function executeMurphDynamicToolRequest(input) {
                 ...toolTextResult(true, 'workout card envelope too large; full text recovery selected'),
                 responseCardTextFallbackPatch: { card: input.request.card },
             };
-        case 'invalid-response-media-arguments':
-            return invalidDynamicToolArgumentsResult('invalid_response_media_arguments', input.request.validationDigest);
-        case 'invalid-send-vault-file-arguments':
-            return toolTextResult(false, 'invalid vault file arguments');
-        case 'invalid-phone-call-arguments':
-            return toolTextResult(false, 'invalid phone-call arguments');
-        case 'invalid-physical-note-arguments':
-            return toolTextResult(false, 'invalid physical-note arguments');
-        case 'invalid-clinical-records-connect-link-arguments':
-            return toolTextResult(false, 'invalid Clinical Records connect-link arguments');
         case 'unsupported-dynamic-tool':
             return toolTextResult(false, 'unsupported dynamic tool');
         case 'attach-group-challenge-response-card':
@@ -1392,12 +1384,25 @@ export async function executeMurphDynamicToolRequest(input) {
                 userActionScope: input.hostedToolContext?.currentUserActionScope?.() ?? null,
                 vaultRoot: input.vaultRoot ?? null,
             });
+        case 'member-memory':
+            return await executeMemberMemoryDynamicTool({
+                available: input.memberMemoryAvailable === true,
+                managedMaintenanceAuthorized: input.memberMemoryMaintenanceAuthorized === true,
+                request: input.request,
+                vaultRoot: input.vaultRoot ?? null,
+            });
         case 'device': {
             const deviceTool = input.hostedToolContext?.deviceTool ?? null;
             if (!deviceTool) {
                 return toolTextResult(false, 'device management is unavailable for this turn');
             }
+            const invocationScope = input.hostedToolContext?.currentInvocationScope?.() ?? null;
+            const acceptedInputAuthority = invocationScope?.conversationScope === 'direct'
+                && invocationScope.origin.kind === 'accepted_input'
+                ? { assistantInputId: invocationScope.origin.assistantInputId }
+                : null;
             return await executeDeviceDynamicTool({
+                acceptedInputAuthority,
                 abortSignal: input.abortSignal ?? null,
                 deviceTool,
                 request: input.request,
@@ -1491,6 +1496,61 @@ export async function executeMurphDynamicToolRequest(input) {
                 return replyRequiredResult(false, 'secure vault-file approval could not be prepared');
             }
         }
+        case 'resolve-physical-note': {
+            const hostedToolContext = input.hostedToolContext ?? null;
+            const resolvePhysicalNote = hostedToolContext?.physicalNotes?.resolve;
+            const userActionScope = hostedToolContext?.currentUserActionScope?.() ?? null;
+            const explicitOriginCandidate = userActionScope
+                ? resolvePhysicalNoteExplicitOriginInputId({
+                    acceptedInputIds: userActionScope.acceptedInputIds,
+                    conversationScope: userActionScope.conversationScope,
+                    messageRef: input.request.messageRef,
+                })
+                : null;
+            const originAssistantInputId = explicitOriginCandidate && userActionScope
+                ? await authorizeDynamicToolEffectOrigin({
+                    authorizer: input.authorizeAcceptedMessageTarget ?? null,
+                    conversationScope: userActionScope.conversationScope,
+                    deliveryContextOrdinal: input.deliveryContextOrdinal ?? null,
+                    messageRef: explicitOriginCandidate,
+                })
+                : null;
+            if (!resolvePhysicalNote || !originAssistantInputId) {
+                return toolTextResult(false, 'physical-note recovery requires the exact current authorizing Message ref and hosted recovery transport');
+            }
+            try {
+                const result = await resolvePhysicalNote({
+                    originAssistantInputId,
+                    ...(input.request.targetMessageRef
+                        ? {
+                            targetKind: input.request.targetKind,
+                            targetOriginAssistantInputId: input.request.targetMessageRef,
+                        }
+                        : {}),
+                }, {
+                    signal: input.abortSignal ?? null,
+                });
+                switch (result.status) {
+                    case 'accepted':
+                        return physicalNoteRecoveryToolResult(true, result.status, result.remainingUnresolved
+                            ? `${physicalNoteRecoveryAcceptedCopy(result.settledUsageCostUsdMicros)} A different unresolved submission remains and needs another explicit recovery request.`
+                            : physicalNoteRecoveryAcceptedCopy(result.settledUsageCostUsdMicros), result.remainingUnresolved, null, result.settledUsageCostUsdMicros, input.request.targetMessageRef ?? null, input.request.targetKind ?? null);
+                    case 'clear':
+                        return physicalNoteRecoveryToolResult(true, result.status, result.remainingUnresolved
+                            ? 'The checked earlier submission was cleared. A different unresolved submission remains and needs another explicit recovery request. This recovery sent nothing.'
+                            : 'The checked earlier submission was cleared. No unresolved physical-note submission remains. This recovery sent nothing; a future note needs a separate request.', result.remainingUnresolved, null, null, input.request.targetMessageRef ?? null, input.request.targetKind ?? null);
+                    case 'pending':
+                        return physicalNoteRecoveryToolResult(true, result.status, 'The earlier outcome is still unconfirmed and cannot be safely cleared. No automatic retry or follow-up is running; this recovery sent nothing.', result.remainingUnresolved, result.retryAfter, null, input.request.targetMessageRef ?? null, input.request.targetKind ?? null);
+                    case 'permission_denied':
+                        return physicalNoteRecoveryToolResult(false, result.status, 'The earlier submission was not changed because recovery is not available to the current participant.', result.remainingUnresolved, null, null, input.request.targetMessageRef ?? null, input.request.targetKind ?? null);
+                    case 'unavailable':
+                        return physicalNoteRecoveryToolResult(false, result.status, 'Physical-note recovery is currently unavailable. The earlier submission was not cleared; nothing new was sent and no automatic retry is running.', result.remainingUnresolved, null, null, input.request.targetMessageRef ?? null, input.request.targetKind ?? null);
+                }
+            }
+            catch {
+                return physicalNoteRecoveryToolResult(false, 'unavailable', 'The recovery response was lost, so the earlier submission\'s final state is unconfirmed. Do not claim it cleared or was accepted. Nothing new was sent and no automatic retry is running.', null, null, null, input.request.targetMessageRef ?? null, input.request.targetKind ?? null);
+            }
+        }
         case 'send-physical-note': {
             const hostedToolContext = input.hostedToolContext ?? null;
             const physicalNotes = hostedToolContext?.physicalNotes ?? null;
@@ -2100,6 +2160,23 @@ export async function executeMurphDynamicToolRequest(input) {
                 voiceMemoRuntime: input.voiceMemoRuntime ?? null,
             });
         }
+        case 'analyze-video': {
+            const userActionScope = input.hostedToolContext?.currentUserActionScope?.() ?? null;
+            if (userActionScope?.conversationScope !== 'direct') {
+                return toolTextResult(false, 'video analysis requires a verified private direct conversation');
+            }
+            return await executeAnalyzeVideoDynamicTool({
+                abortSignal: input.abortSignal ?? null,
+                acceptedInputIds: userActionScope.acceptedInputIds,
+                attachmentAuthorities: input.hostedToolContext
+                    ?.currentAnalyzeVideoAttachmentAuthorities?.() ?? null,
+                args: input.request.args,
+                materializeWorkspaceArtifacts: input.materializeWorkspaceArtifacts ?? null,
+                runtime: input.analyzeVideoRuntime ?? null,
+                turnState: input.analyzeVideoTurnState ?? null,
+                vaultRoot: input.vaultRoot ?? null,
+            });
+        }
         case 'ask-grok': {
             return await executeAskGrokDynamicTool({
                 abortSignal: input.abortSignal ?? null,
@@ -3056,7 +3133,7 @@ function hasExactStringEntries(actual, expected) {
     return actual.length === expected.length
         && actual.every((value, index) => value === expected[index]);
 }
-function buildGroupAccessOfferHostRequest(request) {
+function buildGroupAccessOfferHostRequest(request, repostOriginAssistantInputId) {
     if (request.standaloneLink === true) {
         const joinLink = {
             ...(request.displayName === undefined
@@ -3085,6 +3162,9 @@ function buildGroupAccessOfferHostRequest(request) {
                 ? {}
                 : { projectionScopes: [...request.projectionScopes] }),
         },
+        ...(repostOriginAssistantInputId === null
+            ? {}
+            : { repostOriginAssistantInputId }),
     };
 }
 async function executeGroupTool(input) {
@@ -3131,7 +3211,16 @@ async function executeGroupTool(input) {
     let usageDraft = null;
     let generatedAvatarCapture = null;
     if (input.request.action === 'offer_access') {
-        request = buildGroupAccessOfferHostRequest(input.request);
+        let repostOriginAssistantInputId = null;
+        if (input.request.messageRef !== undefined) {
+            const userActionScope = input.hostedToolContext?.currentUserActionScope?.() ?? null;
+            if (userActionScope?.conversationScope !== 'group'
+                || !userActionScope.acceptedInputIds.includes(input.request.messageRef)) {
+                return toolTextResult(false, 'reposting group access requires the exact current accepted Message ref from this group conversation');
+            }
+            repostOriginAssistantInputId = input.request.messageRef;
+        }
+        request = buildGroupAccessOfferHostRequest(input.request, repostOriginAssistantInputId);
     }
     else if (isPreparedContactCardRequest(input.request)) {
         const userActionScope = input.hostedToolContext?.currentUserActionScope?.() ?? null;
@@ -3266,6 +3355,24 @@ async function executeGroupTool(input) {
             question: input.request.question,
         };
     }
+    else if (input.request.action === 'handoff') {
+        const userActionScope = input.hostedToolContext?.currentUserActionScope?.() ?? null;
+        if (userActionScope?.conversationScope !== 'direct') {
+            return toolTextResult(false, 'group handoff requires a fresh user request in a personal direct conversation');
+        }
+        const originAssistantInputId = userActionScope.acceptedInputIds.at(-1) ?? null;
+        if (!originAssistantInputId) {
+            return toolTextResult(false, 'group handoff requires fresh user-sourced input for this turn');
+        }
+        request = {
+            action: 'handoff',
+            context: input.request.context,
+            ...(input.request.groupLabel === undefined
+                ? {}
+                : { groupLabel: input.request.groupLabel }),
+            originAssistantInputId,
+        };
+    }
     else if (input.request.action === 'ask_current_sender') {
         const userActionScope = input.hostedToolContext?.currentUserActionScope?.() ?? null;
         if (userActionScope?.conversationScope !== 'group'
@@ -4472,8 +4579,25 @@ function toolTextResult(success, text) {
         },
     };
 }
+function physicalNoteRecoveryToolResult(success, status, note, remainingUnresolved, retryAfter = null, settledUsageCostUsdMicros = null, targetMessageRef = null, targetKind = null) {
+    return toolTextResult(success, JSON.stringify({
+        note,
+        remainingUnresolved,
+        retryAfter,
+        settledUsageCostUsdMicros,
+        status,
+        ...(targetMessageRef ? { targetMessageRef } : {}),
+        ...(targetKind ? { targetKind } : {}),
+    }));
+}
+function physicalNoteRecoveryAcceptedCopy(settledUsageCostUsdMicros) {
+    const usage = settledUsageCostUsdMicros === null
+        ? ''
+        : ` The earlier accepted note used ${settledUsageCostUsdMicros} USD micros of Murph time. Recovery itself added no separate fee.`;
+    return `The earlier note was accepted for printing, not delivered, and cannot be treated as canceled.${usage} This recovery sent nothing new.`;
+}
 function invalidDynamicToolArgumentsResult(error, validationDigest) {
-    return toolTextResult(false, buildToolCallValidationFeedback(validationDigest, { error }));
+    return toolTextResult(false, buildToolCallValidationFeedback(validationDigest, error));
 }
 function parseDynamicToolCallRequest(message) {
     const request = readCodexServerRequest(message);
@@ -4741,21 +4865,32 @@ function parseAssistantConfigurationArguments(value) {
         request: parsed.data,
     };
 }
-function parseGroupArguments(value) {
-    const parsed = groupArgumentsSchema.safeParse(value);
+function parseGroupArguments(value, toolName) {
+    const qualifiedToolName = `murph.${toolName}`;
+    const parser = toolName === MURPH_GROUP_TOOL_NAME
+        ? groupArgumentsSchema
+        : groupArgumentsSchema.refine((request) => {
+            const acceptedActions = MURPH_GROUP_TOOL_FAMILY_ACTIONS[toolName];
+            return acceptedActions.includes(request.action);
+        }, {
+            message: 'Action is not accepted by this group tool family.',
+            path: ['action'],
+        });
+    const parsed = parser.safeParse(value);
     if (!parsed.success) {
         return {
             ok: false,
             validationDigest: buildDynamicToolValidationDigest({
                 error: parsed.error,
                 rawInput: value,
-                schemaName: 'murph.group.input',
-                schemaRootKeys: ['action', 'message_ref'],
-                toolName: 'murph.group',
+                schemaName: `${qualifiedToolName}.input`,
+                schemaRootKeys: MURPH_GROUP_TOOL_ROOT_KEYS_BY_NAME[toolName],
+                toolName: qualifiedToolName,
             }),
         };
     }
     if (parsed.data.action === 'ask'
+        || parsed.data.action === 'handoff'
         || parsed.data.action === 'ask_member'
         || parsed.data.action === 'post_disclosure_request'
         || parsed.data.action === 'revoke_disclosure_grant'
@@ -4809,7 +4944,24 @@ function parseGroupArguments(value) {
         return { ok: true, request: parsed.data };
     }
     if (parsed.data.action === 'offer_access') {
-        return { ok: true, request: parsed.data };
+        return {
+            ok: true,
+            request: {
+                action: 'offer_access',
+                ...(parsed.data.displayName === undefined
+                    ? {}
+                    : { displayName: parsed.data.displayName }),
+                ...(parsed.data.message_ref === undefined
+                    ? {}
+                    : { messageRef: parsed.data.message_ref }),
+                ...(parsed.data.projectionScopes === undefined
+                    ? {}
+                    : { projectionScopes: parsed.data.projectionScopes }),
+                ...(parsed.data.standaloneLink === undefined
+                    ? {}
+                    : { standaloneLink: parsed.data.standaloneLink }),
+            },
+        };
     }
     if (parsed.data.action === 'update_display_name') {
         return {
@@ -4866,13 +5018,14 @@ function parseGroupArguments(value) {
                             {
                                 code: z.ZodIssueCode.custom,
                                 message: 'set_chat_avatar with avatarSource="generate" requires prompt',
+                                params: { murphExpectedShape: 'generated_avatar_prompt' },
                                 path: ['prompt'],
                             },
                         ]),
                         rawInput: value,
-                        schemaName: 'murph.group.input',
-                        schemaRootKeys: ['action'],
-                        toolName: 'murph.group',
+                        schemaName: `${qualifiedToolName}.input`,
+                        schemaRootKeys: MURPH_GROUP_TOOL_ROOT_KEYS_BY_NAME[toolName],
+                        toolName: qualifiedToolName,
                     }),
                 };
             }
@@ -4902,13 +5055,14 @@ function parseGroupArguments(value) {
                         {
                             code: z.ZodIssueCode.custom,
                             message: 'set_chat_avatar with avatarSource="image_ref" requires imageRef',
+                            params: { murphExpectedShape: 'existing_avatar_image_ref' },
                             path: ['imageRef'],
                         },
                     ]),
                     rawInput: value,
-                    schemaName: 'murph.group.input',
-                    schemaRootKeys: ['action'],
-                    toolName: 'murph.group',
+                    schemaName: `${qualifiedToolName}.input`,
+                    schemaRootKeys: MURPH_GROUP_TOOL_ROOT_KEYS_BY_NAME[toolName],
+                    toolName: qualifiedToolName,
                 }),
             };
         }
@@ -4974,7 +5128,23 @@ function parseGroupArguments(value) {
             },
         };
     }
-    return { ok: true, request: { action: 'read_current' } };
+    if (parsed.data.action === 'read_current') {
+        return { ok: true, request: { action: 'read_current' } };
+    }
+    return {
+        ok: false,
+        validationDigest: buildDynamicToolValidationDigest({
+            error: new z.ZodError([{
+                    code: z.ZodIssueCode.custom,
+                    message: 'Group action has no explicit normalization path.',
+                    path: ['action'],
+                }]),
+            rawInput: value,
+            schemaName: `${qualifiedToolName}.input`,
+            schemaRootKeys: MURPH_GROUP_TOOL_ROOT_KEYS_BY_NAME[toolName],
+            toolName: qualifiedToolName,
+        }),
+    };
 }
 function readCurrentSenderToolDecision(action) {
     switch (action) {
@@ -5122,7 +5292,8 @@ function parseAttachResponseCardArguments(value, audience) {
     const schemaName = 'murph.attach_response_card.input';
     const toolName = 'murph.attach_response_card';
     if (audience !== 'group') {
-        const parsed = attachResponseCardArgumentsSchema.safeParse(value);
+        const runtimeValue = stampTrackedResponseCardSnapshot(value);
+        const parsed = attachResponseCardArgumentsSchema.safeParse(runtimeValue);
         if (parsed.success) {
             return {
                 card: parsed.data.card,
@@ -5132,7 +5303,7 @@ function parseAttachResponseCardArguments(value, audience) {
         }
         if (audience === 'private'
             || Object.hasOwn(asRecord(value) ?? {}, 'card')) {
-            const semanticWorkout = attachSemanticWorkoutResponseCardArgumentsSchema.safeParse(value);
+            const semanticWorkout = attachSemanticWorkoutResponseCardArgumentsSchema.safeParse(runtimeValue);
             if (semanticWorkout.success) {
                 return {
                     card: semanticWorkout.data.card,
@@ -5140,7 +5311,7 @@ function parseAttachResponseCardArguments(value, audience) {
                     reason: 'workout-envelope-too-large',
                 };
             }
-            const diagnosticError = readAttachResponseCardDiagnosticError(value, parsed.error);
+            const diagnosticError = readAttachResponseCardDiagnosticError(runtimeValue, parsed.error);
             return {
                 ok: false,
                 validationDigest: buildDynamicToolValidationDigest({
@@ -5175,6 +5346,26 @@ function parseAttachResponseCardArguments(value, audience) {
         ok: true,
     };
 }
+function stampTrackedResponseCardSnapshot(value) {
+    const input = asRecord(value);
+    const card = asRecord(input?.card);
+    const tracking = asRecord(card?.tracking);
+    if (card?.kind !== 'compact_table'
+        || tracking?.kind !== 'workout'
+        || !Object.hasOwn(card, 'workout')) {
+        return value;
+    }
+    return {
+        ...input,
+        card: {
+            ...card,
+            tracking: {
+                ...tracking,
+                snapshotAt: new Date().toISOString(),
+            },
+        },
+    };
+}
 function readAttachResponseCardDiagnosticError(value, fallbackError) {
     const card = asRecord(asRecord(value)?.card);
     if (card?.kind === 'daily_nutrition') {