Add Session Coach generation operations

Adds the optional taxonomy args to getLongestRunsLeaderboard and
getMakesLeaderboard (gameType, rankedOnly, excludeDrills, and
table/pocket size bounds) generated from the backend resolvers.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/index.tsx

@@ -2404,6 +2404,11 @@ export type Header = {
   value: Scalars["String"]["output"];
 };
 
+export enum HomographyBackendGql {
+  Classic = "CLASSIC",
+  Tablenet = "TABLENET",
+}
+
 export type HomographyInfoGql = {
   __typename?: "HomographyInfoGQL";
   crop: BoundingBoxGql;
@@ -2549,6 +2554,7 @@ export type Mutation = {
   reactToVideo: Scalars["Boolean"]["output"];
   recalculateChallengeEntry: ChallengeEntry;
   reportContent: Scalars["Boolean"]["output"];
+  requestSessionCoachGeneration: SessionCoachGql;
   requestVideoExport: VideoExportJobGql;
   respondToChallengeInvitation: ChallengeInvitation;
   retireTags: Scalars["Boolean"]["output"];
@@ -2760,6 +2766,10 @@ export type MutationReportContentArgs = {
   videoId: Scalars["Int"]["input"];
 };
 
+export type MutationRequestSessionCoachGenerationArgs = {
+  videoId: Scalars["Int"]["input"];
+};
+
 export type MutationRequestVideoExportArgs = {
   input: RequestVideoExportInput;
 };
@@ -3088,6 +3098,7 @@ export type Query = {
   getQuotaStatus: QuotaStatusGql;
   getResolvedTier: ResolvedTierGql;
   getRuns: GetRunsResult;
+  getSessionCoach: SessionCoachGql;
   getShotAnnotationTypes: Array<ShotAnnotationTypeGql>;
   getShotTableState: ShotTableStateGql;
   getShots: Array<ShotGql>;
@@ -3189,14 +3200,28 @@ export type QueryGetLiveTableStateArgs = {
 };
 
 export type QueryGetLongestRunsLeaderboardArgs = {
+  excludeDrills?: Scalars["Boolean"]["input"];
+  gameType?: InputMaybe<Scalars["String"]["input"]>;
   interval?: InputMaybe<TimeInterval>;
   limit?: Scalars["Int"]["input"];
+  pocketSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
+  pocketSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
+  rankedOnly?: Scalars["Boolean"]["input"];
   requiredTags?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tableSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
+  tableSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
   when?: InputMaybe<Scalars["DateTime"]["input"]>;
 };
 
 export type QueryGetMakesLeaderboardArgs = {
+  excludeDrills?: Scalars["Boolean"]["input"];
+  gameType?: InputMaybe<Scalars["String"]["input"]>;
   interval?: InputMaybe<TimeInterval>;
+  pocketSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
+  pocketSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
+  rankedOnly?: Scalars["Boolean"]["input"];
+  tableSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
+  tableSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
   when?: InputMaybe<Scalars["DateTime"]["input"]>;
 };
 
@@ -3231,6 +3256,10 @@ export type QueryGetRunsArgs = {
   runsOrdering?: InputMaybe<GetRunsOrdering>;
 };
 
+export type QueryGetSessionCoachArgs = {
+  videoId: Scalars["Int"]["input"];
+};
+
 export type QueryGetShotAnnotationTypesArgs = {
   errorTypes?: InputMaybe<Scalars["Boolean"]["input"]>;
 };
@@ -3546,6 +3575,135 @@ export type SerializedShotPathsGql = {
   b64EncodedBuffer?: Maybe<Scalars["String"]["output"]>;
 };
 
+export enum SessionCoachCandidateFamilyEnum {
+  Aiming = "AIMING",
+  BackCut = "BACK_CUT",
+  CueToObjectDistance = "CUE_TO_OBJECT_DISTANCE",
+  CutAngle = "CUT_ANGLE",
+  ObjectToPocketDistance = "OBJECT_TO_POCKET_DISTANCE",
+  Spin = "SPIN",
+}
+
+export type SessionCoachCandidateGql = {
+  __typename?: "SessionCoachCandidateGQL";
+  action: Scalars["String"]["output"];
+  body: Scalars["String"]["output"];
+  drillId?: Maybe<Scalars["String"]["output"]>;
+  evidence: SessionCoachEvidenceGql;
+  family: SessionCoachCandidateFamilyEnum;
+  id: Scalars["ID"]["output"];
+  kind: SessionCoachCandidateKindEnum;
+  limitations: Array<Scalars["String"]["output"]>;
+  rank: Scalars["Int"]["output"];
+  supportingShotIds: Array<Scalars["Int"]["output"]>;
+  title: Scalars["String"]["output"];
+};
+
+export enum SessionCoachCandidateKindEnum {
+  DirectionalMiss = "DIRECTIONAL_MISS",
+  OutcomePattern = "OUTCOME_PATTERN",
+  UsagePattern = "USAGE_PATTERN",
+}
+
+export type SessionCoachDecisionGql = {
+  __typename?: "SessionCoachDecisionGQL";
+  body?: Maybe<Scalars["String"]["output"]>;
+  drillId?: Maybe<Scalars["String"]["output"]>;
+  drillReason?: Maybe<Scalars["String"]["output"]>;
+  practiceAttemptCount?: Maybe<Scalars["Int"]["output"]>;
+  practiceTarget?: Maybe<Scalars["String"]["output"]>;
+  selectedCandidateId?: Maybe<Scalars["ID"]["output"]>;
+  suggestedAction?: Maybe<Scalars["String"]["output"]>;
+  title?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type SessionCoachEvidenceGql = {
+  __typename?: "SessionCoachEvidenceGQL";
+  attemptCount: Scalars["Int"]["output"];
+  bucketKey: Scalars["String"]["output"];
+  bucketLabel: Scalars["String"]["output"];
+  comparisonAttemptCount: Scalars["Int"]["output"];
+  comparisonMadeCount: Scalars["Int"]["output"];
+  comparisonMakePercentage?: Maybe<Scalars["Float"]["output"]>;
+  madeCount: Scalars["Int"]["output"];
+  makePercentage: Scalars["Float"]["output"];
+  missedCount: Scalars["Int"]["output"];
+  patternShotCount: Scalars["Int"]["output"];
+  rankReason: Scalars["String"]["output"];
+  score: Scalars["Float"]["output"];
+};
+
+export type SessionCoachGql = {
+  __typename?: "SessionCoachGQL";
+  agentGeneration?: Maybe<SessionCoachGenerationGql>;
+  analysisVersion: Scalars["String"]["output"];
+  analyzedShotCount: Scalars["Int"]["output"];
+  candidates: Array<SessionCoachCandidateGql>;
+  generatedAt: Scalars["DateTime"]["output"];
+  ineligibilityReason?: Maybe<SessionCoachIneligibilityReasonEnum>;
+  madeCount: Scalars["Int"]["output"];
+  makePercentage?: Maybe<Scalars["Float"]["output"]>;
+  missedCount: Scalars["Int"]["output"];
+  primaryCandidate?: Maybe<SessionCoachCandidateGql>;
+  processingId?: Maybe<Scalars["Int"]["output"]>;
+  processingStatus?: Maybe<Scalars["String"]["output"]>;
+  shotCount: Scalars["Int"]["output"];
+  state: SessionCoachStateEnum;
+  summary?: Maybe<Scalars["String"]["output"]>;
+  unknownOutcomeCount: Scalars["Int"]["output"];
+  videoId: Scalars["Int"]["output"];
+};
+
+export type SessionCoachGenerationDiagnosticsGql = {
+  __typename?: "SessionCoachGenerationDiagnosticsGQL";
+  abstentionReason?: Maybe<Scalars["String"]["output"]>;
+  analysisVersion: Scalars["String"]["output"];
+  attemptCount: Scalars["Int"]["output"];
+  cachedInputTokens?: Maybe<Scalars["Int"]["output"]>;
+  enqueueCount: Scalars["Int"]["output"];
+  failureCode?: Maybe<Scalars["String"]["output"]>;
+  inputHash: Scalars["String"]["output"];
+  inputTokens?: Maybe<Scalars["Int"]["output"]>;
+  lastEnqueuedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  latencyMs?: Maybe<Scalars["Int"]["output"]>;
+  maxAttempts: Scalars["Int"]["output"];
+  modelName: Scalars["String"]["output"];
+  outputTokens?: Maybe<Scalars["Int"]["output"]>;
+  promptVersion: Scalars["String"]["output"];
+  providerKey: Scalars["String"]["output"];
+  startedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  updatedAt: Scalars["DateTime"]["output"];
+};
+
+export type SessionCoachGenerationGql = {
+  __typename?: "SessionCoachGenerationGQL";
+  completedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  createdAt: Scalars["DateTime"]["output"];
+  decision?: Maybe<SessionCoachDecisionGql>;
+  diagnostics?: Maybe<SessionCoachGenerationDiagnosticsGql>;
+  id: Scalars["ID"]["output"];
+  state: SessionCoachGenerationStateEnum;
+};
+
+export enum SessionCoachGenerationStateEnum {
+  Failed = "FAILED",
+  Queued = "QUEUED",
+  Ready = "READY",
+  Running = "RUNNING",
+}
+
+export enum SessionCoachIneligibilityReasonEnum {
+  Multiplayer = "MULTIPLAYER",
+}
+
+export enum SessionCoachStateEnum {
+  Failed = "FAILED",
+  Ineligible = "INELIGIBLE",
+  NoTrackedShots = "NO_TRACKED_SHOTS",
+  Processing = "PROCESSING",
+  Ready = "READY",
+}
+
 export type ShotAnnotationGql = {
   __typename?: "ShotAnnotationGQL";
   createdAt?: Maybe<Scalars["DateTime"]["output"]>;
@@ -4195,6 +4353,7 @@ export type VideoMetadataInput = {
   framesPerSecond?: InputMaybe<Scalars["Float"]["input"]>;
   /** @deprecated `game_type` is deprecated. Use `tags` instead. */
   gameType?: InputMaybe<Scalars["String"]["input"]>;
+  homographyBackend?: InputMaybe<HomographyBackendGql>;
   lastIntendedSegmentBound?: InputMaybe<Scalars["Int"]["input"]>;
   pocketSize?: InputMaybe<Scalars["Float"]["input"]>;
   private?: InputMaybe<Scalars["Boolean"]["input"]>;
@@ -6766,6 +6925,243 @@ export type GetRunsWithTimestampsQuery = {
   };
 };
 
+export type GetSessionCoachQueryVariables = Exact<{
+  videoId: Scalars["Int"]["input"];
+}>;
+
+export type GetSessionCoachQuery = {
+  __typename?: "Query";
+  getSessionCoach: {
+    __typename?: "SessionCoachGQL";
+    videoId: number;
+    processingId?: number | null;
+    analysisVersion: string;
+    state: SessionCoachStateEnum;
+    generatedAt: any;
+    processingStatus?: string | null;
+    ineligibilityReason?: SessionCoachIneligibilityReasonEnum | null;
+    summary?: string | null;
+    shotCount: number;
+    madeCount: number;
+    missedCount: number;
+    unknownOutcomeCount: number;
+    analyzedShotCount: number;
+    makePercentage?: number | null;
+    primaryCandidate?: {
+      __typename?: "SessionCoachCandidateGQL";
+      id: string;
+      rank: number;
+      family: SessionCoachCandidateFamilyEnum;
+      kind: SessionCoachCandidateKindEnum;
+      title: string;
+      body: string;
+      action: string;
+      supportingShotIds: Array<number>;
+      drillId?: string | null;
+      limitations: Array<string>;
+      evidence: {
+        __typename?: "SessionCoachEvidenceGQL";
+        bucketKey: string;
+        bucketLabel: string;
+        attemptCount: number;
+        madeCount: number;
+        missedCount: number;
+        makePercentage: number;
+        comparisonAttemptCount: number;
+        comparisonMadeCount: number;
+        comparisonMakePercentage?: number | null;
+        patternShotCount: number;
+        score: number;
+        rankReason: string;
+      };
+    } | null;
+    candidates: Array<{
+      __typename?: "SessionCoachCandidateGQL";
+      id: string;
+      rank: number;
+      family: SessionCoachCandidateFamilyEnum;
+      kind: SessionCoachCandidateKindEnum;
+      title: string;
+      body: string;
+      action: string;
+      supportingShotIds: Array<number>;
+      drillId?: string | null;
+      limitations: Array<string>;
+      evidence: {
+        __typename?: "SessionCoachEvidenceGQL";
+        bucketKey: string;
+        bucketLabel: string;
+        attemptCount: number;
+        madeCount: number;
+        missedCount: number;
+        makePercentage: number;
+        comparisonAttemptCount: number;
+        comparisonMadeCount: number;
+        comparisonMakePercentage?: number | null;
+        patternShotCount: number;
+        score: number;
+        rankReason: string;
+      };
+    }>;
+    agentGeneration?: {
+      __typename?: "SessionCoachGenerationGQL";
+      id: string;
+      state: SessionCoachGenerationStateEnum;
+      createdAt: any;
+      completedAt?: any | null;
+      decision?: {
+        __typename?: "SessionCoachDecisionGQL";
+        selectedCandidateId?: string | null;
+        title?: string | null;
+        body?: string | null;
+        suggestedAction?: string | null;
+        drillId?: string | null;
+        drillReason?: string | null;
+        practiceAttemptCount?: number | null;
+        practiceTarget?: string | null;
+      } | null;
+      diagnostics?: {
+        __typename?: "SessionCoachGenerationDiagnosticsGQL";
+        analysisVersion: string;
+        promptVersion: string;
+        providerKey: string;
+        modelName: string;
+        inputHash: string;
+        attemptCount: number;
+        maxAttempts: number;
+        enqueueCount: number;
+        latencyMs?: number | null;
+        inputTokens?: number | null;
+        cachedInputTokens?: number | null;
+        outputTokens?: number | null;
+        failureCode?: string | null;
+        updatedAt: any;
+        startedAt?: any | null;
+        lastEnqueuedAt?: any | null;
+        abstentionReason?: string | null;
+      } | null;
+    } | null;
+  };
+};
+
+export type RequestSessionCoachGenerationMutationVariables = Exact<{
+  videoId: Scalars["Int"]["input"];
+}>;
+
+export type RequestSessionCoachGenerationMutation = {
+  __typename?: "Mutation";
+  requestSessionCoachGeneration: {
+    __typename?: "SessionCoachGQL";
+    state: SessionCoachStateEnum;
+    agentGeneration?: {
+      __typename?: "SessionCoachGenerationGQL";
+      id: string;
+      state: SessionCoachGenerationStateEnum;
+      createdAt: any;
+      completedAt?: any | null;
+      decision?: {
+        __typename?: "SessionCoachDecisionGQL";
+        selectedCandidateId?: string | null;
+        title?: string | null;
+        body?: string | null;
+        suggestedAction?: string | null;
+        drillId?: string | null;
+        drillReason?: string | null;
+        practiceAttemptCount?: number | null;
+        practiceTarget?: string | null;
+      } | null;
+      diagnostics?: {
+        __typename?: "SessionCoachGenerationDiagnosticsGQL";
+        analysisVersion: string;
+        promptVersion: string;
+        providerKey: string;
+        modelName: string;
+        inputHash: string;
+        attemptCount: number;
+        maxAttempts: number;
+        enqueueCount: number;
+        latencyMs?: number | null;
+        inputTokens?: number | null;
+        cachedInputTokens?: number | null;
+        outputTokens?: number | null;
+        failureCode?: string | null;
+        updatedAt: any;
+        startedAt?: any | null;
+        lastEnqueuedAt?: any | null;
+        abstentionReason?: string | null;
+      } | null;
+    } | null;
+  };
+};
+
+export type SessionCoachCandidateFieldsFragment = {
+  __typename?: "SessionCoachCandidateGQL";
+  id: string;
+  rank: number;
+  family: SessionCoachCandidateFamilyEnum;
+  kind: SessionCoachCandidateKindEnum;
+  title: string;
+  body: string;
+  action: string;
+  supportingShotIds: Array<number>;
+  drillId?: string | null;
+  limitations: Array<string>;
+  evidence: {
+    __typename?: "SessionCoachEvidenceGQL";
+    bucketKey: string;
+    bucketLabel: string;
+    attemptCount: number;
+    madeCount: number;
+    missedCount: number;
+    makePercentage: number;
+    comparisonAttemptCount: number;
+    comparisonMadeCount: number;
+    comparisonMakePercentage?: number | null;
+    patternShotCount: number;
+    score: number;
+    rankReason: string;
+  };
+};
+
+export type SessionCoachGenerationFieldsFragment = {
+  __typename?: "SessionCoachGenerationGQL";
+  id: string;
+  state: SessionCoachGenerationStateEnum;
+  createdAt: any;
+  completedAt?: any | null;
+  decision?: {
+    __typename?: "SessionCoachDecisionGQL";
+    selectedCandidateId?: string | null;
+    title?: string | null;
+    body?: string | null;
+    suggestedAction?: string | null;
+    drillId?: string | null;
+    drillReason?: string | null;
+    practiceAttemptCount?: number | null;
+    practiceTarget?: string | null;
+  } | null;
+  diagnostics?: {
+    __typename?: "SessionCoachGenerationDiagnosticsGQL";
+    analysisVersion: string;
+    promptVersion: string;
+    providerKey: string;
+    modelName: string;
+    inputHash: string;
+    attemptCount: number;
+    maxAttempts: number;
+    enqueueCount: number;
+    latencyMs?: number | null;
+    inputTokens?: number | null;
+    cachedInputTokens?: number | null;
+    outputTokens?: number | null;
+    failureCode?: string | null;
+    updatedAt: any;
+    startedAt?: any | null;
+    lastEnqueuedAt?: any | null;
+    abstentionReason?: string | null;
+  } | null;
+};
+
 export type PlayerSummaryFieldsFragment = {
   __typename?: "PlayerSummaryGQL";
   clusterId: number;
@@ -9212,6 +9608,71 @@ export const PocketingIntentionFragmentFragmentDoc = gql`
     difficulty
   }
 `;
+export const SessionCoachCandidateFieldsFragmentDoc = gql`
+  fragment SessionCoachCandidateFields on SessionCoachCandidateGQL {
+    id
+    rank
+    family
+    kind
+    title
+    body
+    action
+    supportingShotIds
+    drillId
+    limitations
+    evidence {
+      bucketKey
+      bucketLabel
+      attemptCount
+      madeCount
+      missedCount
+      makePercentage
+      comparisonAttemptCount
+      comparisonMadeCount
+      comparisonMakePercentage
+      patternShotCount
+      score
+      rankReason
+    }
+  }
+`;
+export const SessionCoachGenerationFieldsFragmentDoc = gql`
+  fragment SessionCoachGenerationFields on SessionCoachGenerationGQL {
+    id
+    state
+    createdAt
+    completedAt
+    decision {
+      selectedCandidateId
+      title
+      body
+      suggestedAction
+      drillId
+      drillReason
+      practiceAttemptCount
+      practiceTarget
+    }
+    diagnostics {
+      analysisVersion
+      promptVersion
+      providerKey
+      modelName
+      inputHash
+      attemptCount
+      maxAttempts
+      enqueueCount
+      latencyMs
+      inputTokens
+      cachedInputTokens
+      outputTokens
+      failureCode
+      updatedAt
+      startedAt
+      lastEnqueuedAt
+      abstentionReason
+    }
+  }
+`;
 export const PlayerClusterShotFieldsFragmentDoc = gql`
   fragment PlayerClusterShotFields on PlayerClusterShotGQL {
     shotId
@@ -14700,6 +15161,158 @@ export type GetRunsWithTimestampsQueryResult = Apollo.QueryResult<
   GetRunsWithTimestampsQuery,
   GetRunsWithTimestampsQueryVariables
 >;
+export const GetSessionCoachDocument = gql`
+  query GetSessionCoach($videoId: Int!) {
+    getSessionCoach(videoId: $videoId) {
+      videoId
+      processingId
+      analysisVersion
+      state
+      generatedAt
+      processingStatus
+      ineligibilityReason
+      summary
+      shotCount
+      madeCount
+      missedCount
+      unknownOutcomeCount
+      analyzedShotCount
+      makePercentage
+      primaryCandidate {
+        ...SessionCoachCandidateFields
+      }
+      candidates {
+        ...SessionCoachCandidateFields
+      }
+      agentGeneration {
+        ...SessionCoachGenerationFields
+      }
+    }
+  }
+  ${SessionCoachCandidateFieldsFragmentDoc}
+  ${SessionCoachGenerationFieldsFragmentDoc}
+`;
+
+/**
+ * __useGetSessionCoachQuery__
+ *
+ * To run a query within a React component, call `useGetSessionCoachQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetSessionCoachQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetSessionCoachQuery({
+ *   variables: {
+ *      videoId: // value for 'videoId'
+ *   },
+ * });
+ */
+export function useGetSessionCoachQuery(
+  baseOptions: Apollo.QueryHookOptions<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<GetSessionCoachQuery, GetSessionCoachQueryVariables>(
+    GetSessionCoachDocument,
+    options,
+  );
+}
+export function useGetSessionCoachLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >(GetSessionCoachDocument, options);
+}
+export function useGetSessionCoachSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >(GetSessionCoachDocument, options);
+}
+export type GetSessionCoachQueryHookResult = ReturnType<
+  typeof useGetSessionCoachQuery
+>;
+export type GetSessionCoachLazyQueryHookResult = ReturnType<
+  typeof useGetSessionCoachLazyQuery
+>;
+export type GetSessionCoachSuspenseQueryHookResult = ReturnType<
+  typeof useGetSessionCoachSuspenseQuery
+>;
+export type GetSessionCoachQueryResult = Apollo.QueryResult<
+  GetSessionCoachQuery,
+  GetSessionCoachQueryVariables
+>;
+export const RequestSessionCoachGenerationDocument = gql`
+  mutation RequestSessionCoachGeneration($videoId: Int!) {
+    requestSessionCoachGeneration(videoId: $videoId) {
+      state
+      agentGeneration {
+        ...SessionCoachGenerationFields
+      }
+    }
+  }
+  ${SessionCoachGenerationFieldsFragmentDoc}
+`;
+export type RequestSessionCoachGenerationMutationFn = Apollo.MutationFunction<
+  RequestSessionCoachGenerationMutation,
+  RequestSessionCoachGenerationMutationVariables
+>;
+
+/**
+ * __useRequestSessionCoachGenerationMutation__
+ *
+ * To run a mutation, you first call `useRequestSessionCoachGenerationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRequestSessionCoachGenerationMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [requestSessionCoachGenerationMutation, { data, loading, error }] = useRequestSessionCoachGenerationMutation({
+ *   variables: {
+ *      videoId: // value for 'videoId'
+ *   },
+ * });
+ */
+export function useRequestSessionCoachGenerationMutation(
+  baseOptions?: Apollo.MutationHookOptions<
+    RequestSessionCoachGenerationMutation,
+    RequestSessionCoachGenerationMutationVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useMutation<
+    RequestSessionCoachGenerationMutation,
+    RequestSessionCoachGenerationMutationVariables
+  >(RequestSessionCoachGenerationDocument, options);
+}
+export type RequestSessionCoachGenerationMutationHookResult = ReturnType<
+  typeof useRequestSessionCoachGenerationMutation
+>;
+export type RequestSessionCoachGenerationMutationResult =
+  Apollo.MutationResult<RequestSessionCoachGenerationMutation>;
+export type RequestSessionCoachGenerationMutationOptions =
+  Apollo.BaseMutationOptions<
+    RequestSessionCoachGenerationMutation,
+    RequestSessionCoachGenerationMutationVariables
+  >;
 export const VideoPlayerClustersDocument = gql`
   query VideoPlayerClusters($videoId: Int!) {
     videoPlayerClusters(videoId: $videoId) {

src/operations/session-coach.gql

@@ -0,0 +1,99 @@
+query GetSessionCoach($videoId: Int!) {
+  getSessionCoach(videoId: $videoId) {
+    videoId
+    processingId
+    analysisVersion
+    state
+    generatedAt
+    processingStatus
+    ineligibilityReason
+    summary
+    shotCount
+    madeCount
+    missedCount
+    unknownOutcomeCount
+    analyzedShotCount
+    makePercentage
+    primaryCandidate {
+      ...SessionCoachCandidateFields
+    }
+    candidates {
+      ...SessionCoachCandidateFields
+    }
+    agentGeneration {
+      ...SessionCoachGenerationFields
+    }
+  }
+}
+
+mutation RequestSessionCoachGeneration($videoId: Int!) {
+  requestSessionCoachGeneration(videoId: $videoId) {
+    state
+    agentGeneration {
+      ...SessionCoachGenerationFields
+    }
+  }
+}
+
+fragment SessionCoachCandidateFields on SessionCoachCandidateGQL {
+  id
+  rank
+  family
+  kind
+  title
+  body
+  action
+  supportingShotIds
+  drillId
+  limitations
+  evidence {
+    bucketKey
+    bucketLabel
+    attemptCount
+    madeCount
+    missedCount
+    makePercentage
+    comparisonAttemptCount
+    comparisonMadeCount
+    comparisonMakePercentage
+    patternShotCount
+    score
+    rankReason
+  }
+}
+
+fragment SessionCoachGenerationFields on SessionCoachGenerationGQL {
+  id
+  state
+  createdAt
+  completedAt
+  decision {
+    selectedCandidateId
+    title
+    body
+    suggestedAction
+    drillId
+    drillReason
+    practiceAttemptCount
+    practiceTarget
+  }
+  diagnostics {
+    analysisVersion
+    promptVersion
+    providerKey
+    modelName
+    inputHash
+    attemptCount
+    maxAttempts
+    enqueueCount
+    latencyMs
+    inputTokens
+    cachedInputTokens
+    outputTokens
+    failureCode
+    updatedAt
+    startedAt
+    lastEnqueuedAt
+    abstentionReason
+  }
+}