@labelbox/recursion-sdk 0.0.171 → 0.0.173

package/dist/generated/types.gen.d.ts

@@ -6408,7 +6408,7 @@ export type ImagesResponseDto = {
  */
 export type ImportPlatformLimitsDto = {
     /**
-     * Per-environment maximum import file size in bytes; null means the platform default is in effect.
+     * Platform import-file ceiling in bytes derived from the import worker memory limit; null means no platform ceiling is available.
      */
     maxImportFileSizeBytes: number | null;
 };

package/dist/reference/concepts.js

@@ -163,6 +163,7 @@ export const CONCEPT_REFERENCE = {
         related: [
             'concept:grading-strategies',
             'concept:run-config-roles',
+            'concept:re-grading-runs',
             'recipe:add-and-refine-a-rubric',
             'recipe:create-and-grade-a-problem',
             'resource:rubrics',
@@ -246,6 +247,18 @@ export const CONCEPT_REFERENCE = {
         domain: 'review-qa',
         related: ['recipe:gate-a-stage-on-qa', 'resource:qa', 'resource:qa-gates'],
     },
+    're-grading-runs': {
+        id: 're-grading-runs',
+        title: 'Re-grading runs',
+        domain: 'review-qa',
+        related: [
+            'concept:how-grading-works',
+            'concept:runs-transcripts-and-results',
+            'recipe:regrade-a-run',
+            'recipe:create-and-grade-a-problem',
+            'resource:problem-runs',
+        ],
+    },
     'run-config-anatomy': {
         id: 'run-config-anatomy',
         title: 'Anatomy of a run config',
@@ -279,6 +292,7 @@ export const CONCEPT_REFERENCE = {
             'resource:transcripts',
             'resource:problem-runs',
             'concept:how-async-work-runs',
+            'concept:re-grading-runs',
         ],
     },
     'secrets-and-credentials': {

package/dist/reference/recipes-reference.generated.js

@@ -9275,6 +9275,578 @@ export const RECIPE_REFERENCE = {
             ],
         },
     },
+    'regrade-a-run': {
+        id: 'regrade-a-run',
+        title: 'Re-grade a run',
+        goal: 'Re-score a finished run WITHOUT re-running the solver: create and grade a problem, then re-grade that run against its existing solver transcript — a fast, cheap way to refresh the grade without paying the solver cost again. The prior grade is kept in grade history, so you retain the original result.',
+        category: 'problems',
+        video: 'regrade-a-run.mp4',
+        walkthrough: [
+            {
+                caption: 'Open a problem in the editor',
+                image: '01-open-a-problem-in-the-editor.png',
+                description: 'Open a draft problem version in the editor to configure it.',
+            },
+            {
+                caption: 'Set the task prompt',
+                image: '02-set-the-task-prompt.png',
+                description: 'Write the instruction the solver agent will be given.',
+            },
+            {
+                caption: 'Add a rubric criterion',
+                image: '03-add-a-rubric-criterion.png',
+                description: 'Define how the answer is graded — the criterion the grader checks against.',
+            },
+            {
+                caption: 'Lock the version',
+                image: '04-lock-the-version.png',
+                description: "Lock the version to make it runnable; a locked version can't be edited.",
+            },
+            {
+                caption: 'Run the problem',
+                image: '05-run-the-problem.png',
+                description: 'Start a run — the solver attempts the task in a sandboxed container.',
+            },
+            {
+                caption: 'Review the grade',
+                image: '06-review-the-grade.png',
+                description: 'When grading finishes, the run shows its score against the rubric.',
+            },
+            {
+                caption: 'Open the run to re-grade it',
+                image: '07-open-the-run-to-re-grade-it.png',
+                description: "Open the run's attempt preview, where the Regrade control lives.",
+            },
+            {
+                caption: 'Re-grade without re-running the solver',
+                image: '08-re-grade-without-re-running-the-solver.png',
+                description: 'Re-grade the run — only grading re-runs; the solver transcript is reused.',
+            },
+            {
+                caption: 'See the updated grade',
+                image: '09-see-the-updated-grade.png',
+                description: 'The run shows a Regraded badge and the fresh score; the prior grade moves to grade history.',
+            },
+        ],
+        steps: [
+            {
+                kind: 'intelligence',
+                caption: 'Create a project in Intelligence (its rl-gym environment syncs automatically)',
+                phase: 'setup',
+                gql: {
+                    query: 'mutation CreateProject($data: ProjectCreateInput!) {\n  createProject(data: $data) {\n    id\n  }\n}',
+                    variables: {
+                        data: {
+                            name: 'Recipe demo project',
+                            allowedMediaType: 'RL',
+                            dataRowCount: 1,
+                        },
+                    },
+                },
+                captures: {
+                    projectId: 'createProject.id',
+                },
+            },
+            {
+                kind: 'intelligence',
+                caption: "Find the project's initial labeling queue (reserve a task from it)",
+                phase: 'setup',
+                gql: {
+                    query: 'query ProjectTaskQueues($project: WhereUniqueIdInput!) {\n  project(where: $project) {\n    taskQueues {\n      id\n      queueType\n    }\n  }\n}',
+                    variables: {
+                        project: {
+                            id: {
+                                $ref: 'projectId',
+                            },
+                        },
+                    },
+                },
+                captures: {
+                    queueId: 'project.taskQueues[queueType=INITIAL_LABELING_QUEUE].id',
+                },
+            },
+            {
+                kind: 'intelligence',
+                caption: 'Reserve a task to get a problem to author (data rows sync shortly after the project is created — retry until a task is returned)',
+                phase: 'setup',
+                gql: {
+                    query: 'mutation NextRlTask($where: ReserveRlTaskInput!) {\n  nextRlTask(where: $where) {\n    task {\n      problem {\n        id\n      }\n    }\n  }\n}',
+                    variables: {
+                        where: {
+                            queueId: {
+                                $ref: 'queueId',
+                            },
+                        },
+                    },
+                },
+                captures: {
+                    problemId: 'nextRlTask.task.problem.id',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'getProblem',
+                caption: "Look up the reserved problem's environment",
+                phase: 'setup',
+                inputs: {
+                    problemId: {
+                        $ref: 'problemId',
+                    },
+                },
+                captures: {
+                    environmentId: 'environmentId',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'listProblemVersionsForProblem',
+                caption: 'Open the draft version the reservation created',
+                phase: 'setup',
+                inputs: {
+                    problemId: {
+                        $ref: 'problemId',
+                    },
+                },
+                captures: {
+                    problemVersionId: '[].id',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'createCustomerSecret',
+                caption: 'Provision the Anthropic API key as a customer secret for the solver',
+                phase: 'setup',
+                inputs: {
+                    scope: {
+                        value: {
+                            level: 'env',
+                            id: {
+                                $ref: 'environmentId',
+                            },
+                        },
+                    },
+                    name: {
+                        value: 'ANTHROPIC_API_KEY',
+                    },
+                    upstreamHost: {
+                        value: 'api.anthropic.com',
+                    },
+                    headerName: {
+                        value: 'x-api-key',
+                    },
+                },
+                captures: {
+                    solverSecretId: 'id',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'createRunConfig',
+                caption: "Create the solver run-config identity, scoped to the evaluation's environment",
+                phase: 'setup',
+                inputs: {
+                    scope: {
+                        value: {
+                            level: 'env',
+                            id: {
+                                $ref: 'environmentId',
+                            },
+                        },
+                    },
+                    type: {
+                        value: 'agent-harness',
+                    },
+                    name: {
+                        value: 'Baseline solver',
+                    },
+                },
+                captures: {
+                    solverRunConfigVersionId: 'initialVersionId',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'updateRunConfigVersion',
+                caption: 'Configure the solver draft: harness image, model, egress allowlist, and the secret declaration',
+                phase: 'setup',
+                inputs: {
+                    runConfigVersionId: {
+                        $ref: 'solverRunConfigVersionId',
+                    },
+                    config: {
+                        value: {
+                            harnessImageUrl: 'us-central1-docker.pkg.dev/lb-ml-prod/agent-service/claude-code:latest',
+                            envVars: {
+                                ANTHROPIC_MODEL: 'claude-haiku-4-5-20251001',
+                            },
+                            args: '--max-turns 30',
+                            allowedDomains: ['api.anthropic.com'],
+                            customerSecrets: [
+                                {
+                                    envVarName: 'ANTHROPIC_API_KEY',
+                                },
+                            ],
+                            timeoutSeconds: 600,
+                        },
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'attachCustomerSecret',
+                caption: 'Attach the customer secret to the solver draft version',
+                phase: 'setup',
+                inputs: {
+                    runConfigVersionId: {
+                        $ref: 'solverRunConfigVersionId',
+                    },
+                    customerSecretId: {
+                        $ref: 'solverSecretId',
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'lockRunConfigVersion',
+                caption: 'Lock the verified solver version — only a locked version can be referenced as a solver',
+                phase: 'setup',
+                inputs: {
+                    runConfigVersionId: {
+                        $ref: 'solverRunConfigVersionId',
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'createCustomerSecret',
+                caption: 'Provision the Anthropic API key as a customer secret for the grader',
+                phase: 'setup',
+                inputs: {
+                    scope: {
+                        value: {
+                            level: 'env',
+                            id: {
+                                $ref: 'environmentId',
+                            },
+                        },
+                    },
+                    name: {
+                        value: 'ANTHROPIC_API_KEY',
+                    },
+                    upstreamHost: {
+                        value: 'api.anthropic.com',
+                    },
+                    headerName: {
+                        value: 'x-api-key',
+                    },
+                },
+                captures: {
+                    graderSecretId: 'id',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'createRunConfig',
+                caption: "Create the grader run-config identity, scoped to the evaluation's environment",
+                phase: 'setup',
+                inputs: {
+                    scope: {
+                        value: {
+                            level: 'env',
+                            id: {
+                                $ref: 'environmentId',
+                            },
+                        },
+                    },
+                    type: {
+                        value: 'agent-harness',
+                    },
+                    name: {
+                        value: 'Recipe grader',
+                    },
+                },
+                captures: {
+                    graderRunConfigVersionId: 'initialVersionId',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'updateRunConfigVersion',
+                caption: 'Configure the grader draft: harness image, model, egress allowlist, and the secret declaration',
+                phase: 'setup',
+                inputs: {
+                    runConfigVersionId: {
+                        $ref: 'graderRunConfigVersionId',
+                    },
+                    config: {
+                        value: {
+                            harnessImageUrl: 'us-central1-docker.pkg.dev/lb-ml-prod/agent-service/claude-code:latest',
+                            args: '--model claude-haiku-4-5-20251001 --max-turns 10',
+                            allowedDomains: ['api.anthropic.com'],
+                            customerSecrets: [
+                                {
+                                    envVarName: 'ANTHROPIC_API_KEY',
+                                },
+                            ],
+                            timeoutSeconds: 600,
+                        },
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'attachCustomerSecret',
+                caption: 'Attach the customer secret to the grader draft version',
+                phase: 'setup',
+                inputs: {
+                    runConfigVersionId: {
+                        $ref: 'graderRunConfigVersionId',
+                    },
+                    customerSecretId: {
+                        $ref: 'graderSecretId',
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'lockRunConfigVersion',
+                caption: 'Lock the verified grader version — only a locked version can be referenced as the grader',
+                phase: 'setup',
+                inputs: {
+                    runConfigVersionId: {
+                        $ref: 'graderRunConfigVersionId',
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'updateProblemVersion',
+                caption: 'Set the task prompt and grade it against the rubric',
+                phase: 'main',
+                inputs: {
+                    problemVersionId: {
+                        $ref: 'problemVersionId',
+                    },
+                    prompt: {
+                        value: 'What is the capital of Germany? Answer with just the city name.',
+                    },
+                    gradingConfig: {
+                        value: {
+                            type: 'rubric',
+                        },
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'createProblemVersionRubric',
+                caption: 'Add a rubric to the version',
+                phase: 'main',
+                inputs: {
+                    problemVersionId: {
+                        $ref: 'problemVersionId',
+                    },
+                },
+                captures: {
+                    rubricId: 'id',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'updateProblemVersionRubric',
+                caption: 'Define the rubric criterion',
+                phase: 'main',
+                inputs: {
+                    problemVersionId: {
+                        $ref: 'problemVersionId',
+                    },
+                    rubricId: {
+                        $ref: 'rubricId',
+                    },
+                    criterion: {
+                        value: 'The answer must be Berlin.',
+                    },
+                    weight: {
+                        value: 1,
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'lockProblemVersion',
+                caption: 'Lock the version to make it runnable',
+                phase: 'main',
+                inputs: {
+                    problemVersionId: {
+                        $ref: 'problemVersionId',
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'bulkCreateProblemRuns',
+                caption: 'Grade a solver run against the locked version',
+                phase: 'main',
+                inputs: {
+                    environmentId: {
+                        $ref: 'environmentId',
+                    },
+                    problemVersionIds: {
+                        value: [
+                            {
+                                $ref: 'problemVersionId',
+                            },
+                        ],
+                    },
+                    nAttemptsPerProblem: {
+                        value: 1,
+                    },
+                    runConfigVersionIds: {
+                        value: [
+                            {
+                                $ref: 'solverRunConfigVersionId',
+                            },
+                        ],
+                    },
+                    graderRunConfigVersionId: {
+                        $ref: 'graderRunConfigVersionId',
+                    },
+                    name: {
+                        value: 'Run to re-grade',
+                    },
+                },
+                captures: {
+                    problemRunId: 'problemRunIds[]',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'getProblemRun',
+                caption: 'Wait for the solver run to finish',
+                phase: 'main',
+                inputs: {
+                    problemRunId: {
+                        $ref: 'problemRunId',
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'getProblemRun',
+                caption: 'Wait for the first grade to finalize',
+                phase: 'main',
+                inputs: {
+                    problemRunId: {
+                        $ref: 'problemRunId',
+                    },
+                },
+                captures: {
+                    initialScore: 'finalScore',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'regradeProblemRun',
+                caption: 'Re-grade the run without re-running the solver',
+                phase: 'main',
+                inputs: {
+                    problemRunId: {
+                        $ref: 'problemRunId',
+                    },
+                },
+                captures: {
+                    regradeJobV2Id: 'jobV2Id',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'getJobV2ForEnvironment',
+                caption: 'Wait for the re-grade to finish',
+                phase: 'main',
+                inputs: {
+                    environmentId: {
+                        $ref: 'environmentId',
+                    },
+                    jobV2Id: {
+                        $ref: 'regradeJobV2Id',
+                    },
+                },
+                captures: {},
+            },
+            {
+                kind: 'sdk',
+                operationId: 'getProblemRun',
+                caption: 'Read the new grade',
+                phase: 'main',
+                inputs: {
+                    problemRunId: {
+                        $ref: 'problemRunId',
+                    },
+                },
+                captures: {
+                    regradedScore: 'finalScore',
+                },
+            },
+            {
+                kind: 'sdk',
+                operationId: 'getProblemRun',
+                caption: 'Confirm the run records the re-grade',
+                phase: 'main',
+                inputs: {
+                    problemRunId: {
+                        $ref: 'problemRunId',
+                    },
+                },
+                captures: {
+                    regradeCount: 'regradeCount',
+                },
+            },
+        ],
+        sdk: {
+            setup: "// In Intelligence: Create a project in Intelligence (its rl-gym environment syncs automatically)\nconst projectIdResponse = await fetch('https://app.labelbox.com/api/_gql', {\n  method: 'POST',\n  headers: {\n    Authorization: 'Bearer ' + process.env.LABELBOX_API_KEY,\n    'Content-Type': 'application/json',\n  },\n  body: JSON.stringify({\n    query: `mutation CreateProject($data: ProjectCreateInput!) {\n  createProject(data: $data) {\n    id\n  }\n}`,\n    variables: { data: { name: 'Recipe demo project', allowedMediaType: 'RL', dataRowCount: 1 } },\n  }),\n}).then((response) => response.json());\nif (projectIdResponse.errors?.length) throw new Error(projectIdResponse.errors.map((error) => error.message).join('; '));\nconst projectId = projectIdResponse.data?.createProject?.id;\nif (!projectId) throw new Error('projectId is missing or false in the response (it may still be syncing, or the operation failed) — retry');\n\n// In Intelligence: Find the project's initial labeling queue (reserve a task from it)\nconst queueIdResponse = await fetch('https://app.labelbox.com/api/_gql', {\n  method: 'POST',\n  headers: {\n    Authorization: 'Bearer ' + process.env.LABELBOX_API_KEY,\n    'Content-Type': 'application/json',\n  },\n  body: JSON.stringify({\n    query: `query ProjectTaskQueues($project: WhereUniqueIdInput!) {\n  project(where: $project) {\n    taskQueues {\n      id\n      queueType\n    }\n  }\n}`,\n    variables: { project: { id: projectId } },\n  }),\n}).then((response) => response.json());\nif (queueIdResponse.errors?.length) throw new Error(queueIdResponse.errors.map((error) => error.message).join('; '));\nconst queueId = queueIdResponse.data?.project?.taskQueues?.find((item) => item.queueType === \"INITIAL_LABELING_QUEUE\")?.id;\nif (!queueId) throw new Error('queueId is missing or false in the response (it may still be syncing, or the operation failed) — retry');\n\n// In Intelligence: Reserve a task to get a problem to author (data rows sync shortly after the project is created — retry until a task is returned)\nconst problemIdResponse = await fetch('https://app.labelbox.com/api/_gql', {\n  method: 'POST',\n  headers: {\n    Authorization: 'Bearer ' + process.env.LABELBOX_API_KEY,\n    'Content-Type': 'application/json',\n  },\n  body: JSON.stringify({\n    query: `mutation NextRlTask($where: ReserveRlTaskInput!) {\n  nextRlTask(where: $where) {\n    task {\n      problem {\n        id\n      }\n    }\n  }\n}`,\n    variables: { where: { queueId: queueId } },\n  }),\n}).then((response) => response.json());\nif (problemIdResponse.errors?.length) throw new Error(problemIdResponse.errors.map((error) => error.message).join('; '));\nconst problemId = problemIdResponse.data?.nextRlTask?.task?.problem?.id;\nif (!problemId) throw new Error('problemId is missing or false in the response (it may still be syncing, or the operation failed) — retry');\n\n// Look up the reserved problem's environment\nconst problem = await rl.problems.get({\n  problemId,\n});\nconst environmentId = problem.environmentId;\n\n// Open the draft version the reservation created\nconst problemVersion = await rl.problemVersions.listForProblem({\n  problemId,\n});\nconst problemVersionId = problemVersion[0]?.id;\nif (problemVersionId == null) throw new Error('problemVersionId not found in the response (it may still be syncing) — retry');\n\n// Provision the Anthropic API key as a customer secret for the solver\nconst customerSecret = await rl.customerSecrets.create({\n  body: {\n    scope: { level: 'env', id: environmentId },\n    name: 'ANTHROPIC_API_KEY',\n    upstreamHost: 'api.anthropic.com',\n    headerName: 'x-api-key',\n    value: '<value>',\n  },\n});\nconst solverSecretId = customerSecret.id;\n\n// Create the solver run-config identity, scoped to the evaluation's environment\nconst runConfig = await rl.runConfigs.create({\n  body: {\n    scope: { level: 'env', id: environmentId },\n    type: 'agent-harness',\n    name: 'Baseline solver',\n  },\n});\nconst solverRunConfigVersionId = runConfig.initialVersionId;\n\n// Configure the solver draft: harness image, model, egress allowlist, and the secret declaration\nawait rl.runConfigVersions.update({\n  runConfigVersionId: solverRunConfigVersionId,\n  body: {\n    config: { harnessImageUrl: 'us-central1-docker.pkg.dev/lb-ml-prod/agent-service/claude-code:latest', envVars: { ANTHROPIC_MODEL: 'claude-haiku-4-5-20251001' }, args: '--max-turns 30', allowedDomains: ['api.anthropic.com'], customerSecrets: [{ envVarName: 'ANTHROPIC_API_KEY' }], timeoutSeconds: 600 },\n  },\n});\n\n// Attach the customer secret to the solver draft version\nawait rl.customerSecrets.attach({\n  runConfigVersionId: solverRunConfigVersionId,\n  customerSecretId: solverSecretId,\n});\n\n// Lock the verified solver version — only a locked version can be referenced as a solver\nawait rl.runConfigVersions.lock({\n  runConfigVersionId: solverRunConfigVersionId,\n});\n\n// Provision the Anthropic API key as a customer secret for the grader\nconst customerSecret2 = await rl.customerSecrets.create({\n  body: {\n    scope: { level: 'env', id: environmentId },\n    name: 'ANTHROPIC_API_KEY',\n    upstreamHost: 'api.anthropic.com',\n    headerName: 'x-api-key',\n    value: '<value>',\n  },\n});\nconst graderSecretId = customerSecret2.id;\n\n// Create the grader run-config identity, scoped to the evaluation's environment\nconst runConfig2 = await rl.runConfigs.create({\n  body: {\n    scope: { level: 'env', id: environmentId },\n    type: 'agent-harness',\n    name: 'Recipe grader',\n  },\n});\nconst graderRunConfigVersionId = runConfig2.initialVersionId;\n\n// Configure the grader draft: harness image, model, egress allowlist, and the secret declaration\nawait rl.runConfigVersions.update({\n  runConfigVersionId: graderRunConfigVersionId,\n  body: {\n    config: { harnessImageUrl: 'us-central1-docker.pkg.dev/lb-ml-prod/agent-service/claude-code:latest', args: '--model claude-haiku-4-5-20251001 --max-turns 10', allowedDomains: ['api.anthropic.com'], customerSecrets: [{ envVarName: 'ANTHROPIC_API_KEY' }], timeoutSeconds: 600 },\n  },\n});\n\n// Attach the customer secret to the grader draft version\nawait rl.customerSecrets.attach({\n  runConfigVersionId: graderRunConfigVersionId,\n  customerSecretId: graderSecretId,\n});\n\n// Lock the verified grader version — only a locked version can be referenced as the grader\nawait rl.runConfigVersions.lock({\n  runConfigVersionId: graderRunConfigVersionId,\n});",
+            main: "// Set the task prompt and grade it against the rubric\nawait rl.problemVersions.update({\n  problemVersionId,\n  body: {\n    prompt: 'What is the capital of Germany? Answer with just the city name.',\n    gradingConfig: { type: 'rubric' },\n  },\n});\n\n// Add a rubric to the version\nconst rubric = await rl.rubrics.create({\n  problemVersionId,\n});\nconst rubricId = rubric.id;\n\n// Define the rubric criterion\nawait rl.rubrics.update({\n  problemVersionId,\n  rubricId,\n  body: {\n    criterion: 'The answer must be Berlin.',\n    weight: 1,\n  },\n});\n\n// Lock the version to make it runnable\nawait rl.problemVersions.lock({\n  problemVersionId,\n});\n\n// Grade a solver run against the locked version\nconst problemRun = await rl.problemRuns.bulkCreate({\n  body: {\n    environmentId,\n    name: 'Run to re-grade',\n    problemVersionIds: [problemVersionId],\n    nAttemptsPerProblem: 1,\n    runConfigVersionIds: [solverRunConfigVersionId],\n    graderRunConfigVersionId,\n  },\n});\nconst problemRunId = problemRun.problemRunIds[0];\nif (problemRunId == null) throw new Error('problemRunId not found in the response (it may still be syncing) — retry');\n\n// Wait for the solver run to finish\nlet problemRun2;\nconst problemRun2Deadline = Date.now() + 900000;\nfor (;;) {\n  problemRun2 = await rl.problemRuns.get({\n    problemRunId,\n  });\n  if (['failed', 'cancelled'].includes(problemRun2.status)) throw new Error('reached a terminal failure state: ' + problemRun2.status);\n  if (['grading', 'completed'].includes(problemRun2.status)) break;\n  if (Date.now() > problemRun2Deadline) throw new Error('timed out after 900000ms waiting for a terminal state');\n  await new Promise((resolve) => setTimeout(resolve, 5000));\n}\n\n// Wait for the first grade to finalize\nlet problemRun3;\nconst problemRun3Deadline = Date.now() + 900000;\nfor (;;) {\n  problemRun3 = await rl.problemRuns.get({\n    problemRunId,\n  });\n  if (['failed', 'cancelled'].includes(problemRun3.status)) throw new Error('reached a terminal failure state: ' + problemRun3.status);\n  if (problemRun3.gradedAt != null) break;\n  if (Date.now() > problemRun3Deadline) throw new Error('timed out after 900000ms waiting for a terminal state');\n  await new Promise((resolve) => setTimeout(resolve, 5000));\n}\nconst initialScore = problemRun3.finalScore;\n\n// Re-grade the run without re-running the solver\nconst problemRun4 = await rl.problemRuns.regrade({\n  problemRunId,\n});\nconst regradeJobV2Id = problemRun4.jobV2Id;\n\n// Wait for the re-grade to finish\nlet jobsV2;\nconst jobsV2Deadline = Date.now() + 900000;\nfor (;;) {\n  jobsV2 = await rl.jobsV2.getForEnvironment({\n    environmentId,\n    jobV2Id: regradeJobV2Id,\n  });\n  if (['failed', 'cancelled'].includes(jobsV2.status)) throw new Error('reached a terminal failure state: ' + jobsV2.status);\n  if (['completed'].includes(jobsV2.status)) break;\n  if (Date.now() > jobsV2Deadline) throw new Error('timed out after 900000ms waiting for a terminal state');\n  await new Promise((resolve) => setTimeout(resolve, 5000));\n}\n\n// Read the new grade\nconst problemRun5 = await rl.problemRuns.get({\n  problemRunId,\n});\nconst regradedScore = problemRun5.finalScore;\n\n// Confirm the run records the re-grade\nconst problemRun6 = await rl.problemRuns.get({\n  problemRunId,\n});\nconst regradeCount = problemRun6.regradeCount;",
+        },
+        cli: {
+            setup: '# In Intelligence: Create a project in Intelligence (its rl-gym environment syncs automatically)\nPROJECT_ID=$(curl -s -X POST "https://app.labelbox.com/api/_gql" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"query\\": \\"mutation CreateProject(\\$data: ProjectCreateInput!) {\\\\n  createProject(data: \\$data) {\\\\n    id\\\\n  }\\\\n}\\", \\"variables\\": { \\"data\\": { \\"name\\": \\"Recipe demo project\\", \\"allowedMediaType\\": \\"RL\\", \\"dataRowCount\\": 1 } } }" \\\n  | jq -r \'.data.createProject.id\')\n\n# In Intelligence: Find the project\'s initial labeling queue (reserve a task from it)\nQUEUE_ID=$(curl -s -X POST "https://app.labelbox.com/api/_gql" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"query\\": \\"query ProjectTaskQueues(\\$project: WhereUniqueIdInput!) {\\\\n  project(where: \\$project) {\\\\n    taskQueues {\\\\n      id\\\\n      queueType\\\\n    }\\\\n  }\\\\n}\\", \\"variables\\": { \\"project\\": { \\"id\\": \\"$PROJECT_ID\\" } } }" \\\n  | jq -r \'.data.project.taskQueues[] | select(.queueType == "INITIAL_LABELING_QUEUE") | .id\')\n\n# In Intelligence: Reserve a task to get a problem to author (data rows sync shortly after the project is created — retry until a task is returned)\nPROBLEM_ID=$(curl -s -X POST "https://app.labelbox.com/api/_gql" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"query\\": \\"mutation NextRlTask(\\$where: ReserveRlTaskInput!) {\\\\n  nextRlTask(where: \\$where) {\\\\n    task {\\\\n      problem {\\\\n        id\\\\n      }\\\\n    }\\\\n  }\\\\n}\\", \\"variables\\": { \\"where\\": { \\"queueId\\": \\"$QUEUE_ID\\" } } }" \\\n  | jq -r \'.data.nextRlTask.task.problem.id\')\n\n# Look up the reserved problem\'s environment\nENVIRONMENT_ID=$(rl problems get \\\n  --problem-id "$PROBLEM_ID" \\\n  | jq -r \'.environmentId\')\n\n# Open the draft version the reservation created\nPROBLEM_VERSION_ID=$(rl problem-versions list-for-problem \\\n  --problem-id "$PROBLEM_ID" \\\n  | jq -r \'.[0].id\')\n\n# Provision the Anthropic API key as a customer secret for the solver\nSOLVER_SECRET_ID=$(rl customer-secrets create \\\n  --data "{ \\"scope\\": { \\"level\\": \\"env\\", \\"id\\": \\"$ENVIRONMENT_ID\\" }, \\"name\\": \\"ANTHROPIC_API_KEY\\", \\"upstreamHost\\": \\"api.anthropic.com\\", \\"headerName\\": \\"x-api-key\\", \\"value\\": \\"<value>\\" }" \\\n  | jq -r \'.id\')\n\n# Create the solver run-config identity, scoped to the evaluation\'s environment\nSOLVER_RUN_CONFIG_VERSION_ID=$(rl run-configs create \\\n  --data "{ \\"scope\\": { \\"level\\": \\"env\\", \\"id\\": \\"$ENVIRONMENT_ID\\" }, \\"type\\": \\"agent-harness\\", \\"name\\": \\"Baseline solver\\" }" \\\n  | jq -r \'.initialVersionId\')\n\n# Configure the solver draft: harness image, model, egress allowlist, and the secret declaration\nrl run-config-versions update \\\n  --run-config-version-id "$SOLVER_RUN_CONFIG_VERSION_ID" \\\n  --data "{ \\"config\\": { \\"harnessImageUrl\\": \\"us-central1-docker.pkg.dev/lb-ml-prod/agent-service/claude-code:latest\\", \\"envVars\\": { \\"ANTHROPIC_MODEL\\": \\"claude-haiku-4-5-20251001\\" }, \\"args\\": \\"--max-turns 30\\", \\"allowedDomains\\": [\\"api.anthropic.com\\"], \\"customerSecrets\\": [{ \\"envVarName\\": \\"ANTHROPIC_API_KEY\\" }], \\"timeoutSeconds\\": 600 } }"\n\n# Attach the customer secret to the solver draft version\nrl customer-secrets attach \\\n  --run-config-version-id "$SOLVER_RUN_CONFIG_VERSION_ID" \\\n  --customer-secret-id "$SOLVER_SECRET_ID"\n\n# Lock the verified solver version — only a locked version can be referenced as a solver\nrl run-config-versions lock \\\n  --run-config-version-id "$SOLVER_RUN_CONFIG_VERSION_ID"\n\n# Provision the Anthropic API key as a customer secret for the grader\nGRADER_SECRET_ID=$(rl customer-secrets create \\\n  --data "{ \\"scope\\": { \\"level\\": \\"env\\", \\"id\\": \\"$ENVIRONMENT_ID\\" }, \\"name\\": \\"ANTHROPIC_API_KEY\\", \\"upstreamHost\\": \\"api.anthropic.com\\", \\"headerName\\": \\"x-api-key\\", \\"value\\": \\"<value>\\" }" \\\n  | jq -r \'.id\')\n\n# Create the grader run-config identity, scoped to the evaluation\'s environment\nGRADER_RUN_CONFIG_VERSION_ID=$(rl run-configs create \\\n  --data "{ \\"scope\\": { \\"level\\": \\"env\\", \\"id\\": \\"$ENVIRONMENT_ID\\" }, \\"type\\": \\"agent-harness\\", \\"name\\": \\"Recipe grader\\" }" \\\n  | jq -r \'.initialVersionId\')\n\n# Configure the grader draft: harness image, model, egress allowlist, and the secret declaration\nrl run-config-versions update \\\n  --run-config-version-id "$GRADER_RUN_CONFIG_VERSION_ID" \\\n  --data "{ \\"config\\": { \\"harnessImageUrl\\": \\"us-central1-docker.pkg.dev/lb-ml-prod/agent-service/claude-code:latest\\", \\"args\\": \\"--model claude-haiku-4-5-20251001 --max-turns 10\\", \\"allowedDomains\\": [\\"api.anthropic.com\\"], \\"customerSecrets\\": [{ \\"envVarName\\": \\"ANTHROPIC_API_KEY\\" }], \\"timeoutSeconds\\": 600 } }"\n\n# Attach the customer secret to the grader draft version\nrl customer-secrets attach \\\n  --run-config-version-id "$GRADER_RUN_CONFIG_VERSION_ID" \\\n  --customer-secret-id "$GRADER_SECRET_ID"\n\n# Lock the verified grader version — only a locked version can be referenced as the grader\nrl run-config-versions lock \\\n  --run-config-version-id "$GRADER_RUN_CONFIG_VERSION_ID"',
+            main: '# Set the task prompt and grade it against the rubric\nrl problem-versions update \\\n  --problem-version-id "$PROBLEM_VERSION_ID" \\\n  --data "{ \\"prompt\\": \\"What is the capital of Germany? Answer with just the city name.\\", \\"gradingConfig\\": { \\"type\\": \\"rubric\\" } }"\n\n# Add a rubric to the version\nRUBRIC_ID=$(rl rubrics create \\\n  --problem-version-id "$PROBLEM_VERSION_ID" \\\n  | jq -r \'.id\')\n\n# Define the rubric criterion\nrl rubrics update \\\n  --problem-version-id "$PROBLEM_VERSION_ID" \\\n  --rubric-id "$RUBRIC_ID" \\\n  --data "{ \\"criterion\\": \\"The answer must be Berlin.\\", \\"weight\\": 1 }"\n\n# Lock the version to make it runnable\nrl problem-versions lock \\\n  --problem-version-id "$PROBLEM_VERSION_ID"\n\n# Grade a solver run against the locked version\nPROBLEM_RUN_ID=$(rl problem-runs bulk-create \\\n  --data "{ \\"environmentId\\": \\"$ENVIRONMENT_ID\\", \\"name\\": \\"Run to re-grade\\", \\"problemVersionIds\\": [\\"$PROBLEM_VERSION_ID\\"], \\"nAttemptsPerProblem\\": 1, \\"runConfigVersionIds\\": [\\"$SOLVER_RUN_CONFIG_VERSION_ID\\"], \\"graderRunConfigVersionId\\": \\"$GRADER_RUN_CONFIG_VERSION_ID\\" }" \\\n  | jq -r \'.problemRunIds[0]\')\n\n# Wait for the solver run to finish\ndeadline=$(( $(date +%s) + 900 ))\nwhile :; do\n  response=$(rl problem-runs get \\\n  --problem-run-id "$PROBLEM_RUN_ID")\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in failed|cancelled) echo "reached a terminal failure state: $response" >&2; exit 1 ;; esac\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in grading|completed) break ;; esac\n  [ "$(date +%s)" -ge "$deadline" ] && { echo "timed out waiting for a terminal state" >&2; exit 1; }\n  sleep 5\ndone\n\n# Wait for the first grade to finalize\ndeadline=$(( $(date +%s) + 900 ))\nwhile :; do\n  response=$(rl problem-runs get \\\n  --problem-run-id "$PROBLEM_RUN_ID")\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in failed|cancelled) echo "reached a terminal failure state: $response" >&2; exit 1 ;; esac\n  printf \'%s\' "$response" | jq -e \'.gradedAt != null\' >/dev/null && { break; }\n  [ "$(date +%s)" -ge "$deadline" ] && { echo "timed out waiting for a terminal state" >&2; exit 1; }\n  sleep 5\ndone\nINITIAL_SCORE=$(printf \'%s\' "$response" | jq -r \'.finalScore\')\n\n# Re-grade the run without re-running the solver\nREGRADE_JOB_V2_ID=$(rl problem-runs regrade \\\n  --problem-run-id "$PROBLEM_RUN_ID" \\\n  | jq -r \'.jobV2Id\')\n\n# Wait for the re-grade to finish\ndeadline=$(( $(date +%s) + 900 ))\nwhile :; do\n  response=$(rl jobs-v2 get-for-environment \\\n  --environment-id "$ENVIRONMENT_ID" \\\n  --job-v2-id "$REGRADE_JOB_V2_ID")\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in failed|cancelled) echo "reached a terminal failure state: $response" >&2; exit 1 ;; esac\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in completed) break ;; esac\n  [ "$(date +%s)" -ge "$deadline" ] && { echo "timed out waiting for a terminal state" >&2; exit 1; }\n  sleep 5\ndone\n\n# Read the new grade\nREGRADED_SCORE=$(rl problem-runs get \\\n  --problem-run-id "$PROBLEM_RUN_ID" \\\n  | jq -r \'.finalScore\')\n\n# Confirm the run records the re-grade\nREGRADE_COUNT=$(rl problem-runs get \\\n  --problem-run-id "$PROBLEM_RUN_ID" \\\n  | jq -r \'.regradeCount\')',
+        },
+        curl: {
+            setup: '# In Intelligence: Create a project in Intelligence (its rl-gym environment syncs automatically)\nPROJECT_ID=$(curl -s -X POST "https://app.labelbox.com/api/_gql" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"query\\": \\"mutation CreateProject(\\$data: ProjectCreateInput!) {\\\\n  createProject(data: \\$data) {\\\\n    id\\\\n  }\\\\n}\\", \\"variables\\": { \\"data\\": { \\"name\\": \\"Recipe demo project\\", \\"allowedMediaType\\": \\"RL\\", \\"dataRowCount\\": 1 } } }" \\\n  | jq -r \'.data.createProject.id\')\n\n# In Intelligence: Find the project\'s initial labeling queue (reserve a task from it)\nQUEUE_ID=$(curl -s -X POST "https://app.labelbox.com/api/_gql" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"query\\": \\"query ProjectTaskQueues(\\$project: WhereUniqueIdInput!) {\\\\n  project(where: \\$project) {\\\\n    taskQueues {\\\\n      id\\\\n      queueType\\\\n    }\\\\n  }\\\\n}\\", \\"variables\\": { \\"project\\": { \\"id\\": \\"$PROJECT_ID\\" } } }" \\\n  | jq -r \'.data.project.taskQueues[] | select(.queueType == "INITIAL_LABELING_QUEUE") | .id\')\n\n# In Intelligence: Reserve a task to get a problem to author (data rows sync shortly after the project is created — retry until a task is returned)\nPROBLEM_ID=$(curl -s -X POST "https://app.labelbox.com/api/_gql" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"query\\": \\"mutation NextRlTask(\\$where: ReserveRlTaskInput!) {\\\\n  nextRlTask(where: \\$where) {\\\\n    task {\\\\n      problem {\\\\n        id\\\\n      }\\\\n    }\\\\n  }\\\\n}\\", \\"variables\\": { \\"where\\": { \\"queueId\\": \\"$QUEUE_ID\\" } } }" \\\n  | jq -r \'.data.nextRlTask.task.problem.id\')\n\n# Look up the reserved problem\'s environment\nENVIRONMENT_ID=$(curl -s -X GET "https://api.recursion.labelbox.com/v1/problems/$PROBLEM_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  | jq -r \'.environmentId\')\n\n# Open the draft version the reservation created\nPROBLEM_VERSION_ID=$(curl -s -X GET "https://api.recursion.labelbox.com/v1/problems/$PROBLEM_ID/versions" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  | jq -r \'.[0].id\')\n\n# Provision the Anthropic API key as a customer secret for the solver\nSOLVER_SECRET_ID=$(curl -s -X POST "https://api.recursion.labelbox.com/v1/customer-secrets" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"scope\\": { \\"level\\": \\"env\\", \\"id\\": \\"$ENVIRONMENT_ID\\" }, \\"name\\": \\"ANTHROPIC_API_KEY\\", \\"upstreamHost\\": \\"api.anthropic.com\\", \\"headerName\\": \\"x-api-key\\", \\"value\\": \\"<value>\\" }" \\\n  | jq -r \'.id\')\n\n# Create the solver run-config identity, scoped to the evaluation\'s environment\nSOLVER_RUN_CONFIG_VERSION_ID=$(curl -s -X POST "https://api.recursion.labelbox.com/v1/run-configs" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"scope\\": { \\"level\\": \\"env\\", \\"id\\": \\"$ENVIRONMENT_ID\\" }, \\"type\\": \\"agent-harness\\", \\"name\\": \\"Baseline solver\\" }" \\\n  | jq -r \'.initialVersionId\')\n\n# Configure the solver draft: harness image, model, egress allowlist, and the secret declaration\ncurl -s -X PATCH "https://api.recursion.labelbox.com/v1/run-config-versions/$SOLVER_RUN_CONFIG_VERSION_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"config\\": { \\"harnessImageUrl\\": \\"us-central1-docker.pkg.dev/lb-ml-prod/agent-service/claude-code:latest\\", \\"envVars\\": { \\"ANTHROPIC_MODEL\\": \\"claude-haiku-4-5-20251001\\" }, \\"args\\": \\"--max-turns 30\\", \\"allowedDomains\\": [\\"api.anthropic.com\\"], \\"customerSecrets\\": [{ \\"envVarName\\": \\"ANTHROPIC_API_KEY\\" }], \\"timeoutSeconds\\": 600 } }"\n\n# Attach the customer secret to the solver draft version\ncurl -s -X POST "https://api.recursion.labelbox.com/v1/run-config-versions/$SOLVER_RUN_CONFIG_VERSION_ID/customer-secrets/$SOLVER_SECRET_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY"\n\n# Lock the verified solver version — only a locked version can be referenced as a solver\ncurl -s -X POST "https://api.recursion.labelbox.com/v1/run-config-versions/$SOLVER_RUN_CONFIG_VERSION_ID/lock" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY"\n\n# Provision the Anthropic API key as a customer secret for the grader\nGRADER_SECRET_ID=$(curl -s -X POST "https://api.recursion.labelbox.com/v1/customer-secrets" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"scope\\": { \\"level\\": \\"env\\", \\"id\\": \\"$ENVIRONMENT_ID\\" }, \\"name\\": \\"ANTHROPIC_API_KEY\\", \\"upstreamHost\\": \\"api.anthropic.com\\", \\"headerName\\": \\"x-api-key\\", \\"value\\": \\"<value>\\" }" \\\n  | jq -r \'.id\')\n\n# Create the grader run-config identity, scoped to the evaluation\'s environment\nGRADER_RUN_CONFIG_VERSION_ID=$(curl -s -X POST "https://api.recursion.labelbox.com/v1/run-configs" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"scope\\": { \\"level\\": \\"env\\", \\"id\\": \\"$ENVIRONMENT_ID\\" }, \\"type\\": \\"agent-harness\\", \\"name\\": \\"Recipe grader\\" }" \\\n  | jq -r \'.initialVersionId\')\n\n# Configure the grader draft: harness image, model, egress allowlist, and the secret declaration\ncurl -s -X PATCH "https://api.recursion.labelbox.com/v1/run-config-versions/$GRADER_RUN_CONFIG_VERSION_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"config\\": { \\"harnessImageUrl\\": \\"us-central1-docker.pkg.dev/lb-ml-prod/agent-service/claude-code:latest\\", \\"args\\": \\"--model claude-haiku-4-5-20251001 --max-turns 10\\", \\"allowedDomains\\": [\\"api.anthropic.com\\"], \\"customerSecrets\\": [{ \\"envVarName\\": \\"ANTHROPIC_API_KEY\\" }], \\"timeoutSeconds\\": 600 } }"\n\n# Attach the customer secret to the grader draft version\ncurl -s -X POST "https://api.recursion.labelbox.com/v1/run-config-versions/$GRADER_RUN_CONFIG_VERSION_ID/customer-secrets/$GRADER_SECRET_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY"\n\n# Lock the verified grader version — only a locked version can be referenced as the grader\ncurl -s -X POST "https://api.recursion.labelbox.com/v1/run-config-versions/$GRADER_RUN_CONFIG_VERSION_ID/lock" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY"',
+            main: '# Set the task prompt and grade it against the rubric\ncurl -s -X PATCH "https://api.recursion.labelbox.com/v1/versions/$PROBLEM_VERSION_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"prompt\\": \\"What is the capital of Germany? Answer with just the city name.\\", \\"gradingConfig\\": { \\"type\\": \\"rubric\\" } }"\n\n# Add a rubric to the version\nRUBRIC_ID=$(curl -s -X POST "https://api.recursion.labelbox.com/v1/versions/$PROBLEM_VERSION_ID/rubrics" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  | jq -r \'.id\')\n\n# Define the rubric criterion\ncurl -s -X PATCH "https://api.recursion.labelbox.com/v1/versions/$PROBLEM_VERSION_ID/rubrics/$RUBRIC_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"criterion\\": \\"The answer must be Berlin.\\", \\"weight\\": 1 }"\n\n# Lock the version to make it runnable\ncurl -s -X PUT "https://api.recursion.labelbox.com/v1/versions/$PROBLEM_VERSION_ID/lock" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY"\n\n# Grade a solver run against the locked version\nPROBLEM_RUN_ID=$(curl -s -X POST "https://api.recursion.labelbox.com/v1/problem-runs/bulk" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  -H "Content-Type: application/json" \\\n  -d "{ \\"environmentId\\": \\"$ENVIRONMENT_ID\\", \\"name\\": \\"Run to re-grade\\", \\"problemVersionIds\\": [\\"$PROBLEM_VERSION_ID\\"], \\"nAttemptsPerProblem\\": 1, \\"runConfigVersionIds\\": [\\"$SOLVER_RUN_CONFIG_VERSION_ID\\"], \\"graderRunConfigVersionId\\": \\"$GRADER_RUN_CONFIG_VERSION_ID\\" }" \\\n  | jq -r \'.problemRunIds[0]\')\n\n# Wait for the solver run to finish\ndeadline=$(( $(date +%s) + 900 ))\nwhile :; do\n  response=$(curl -s -X GET "https://api.recursion.labelbox.com/v1/problem-runs/$PROBLEM_RUN_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY")\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in failed|cancelled) echo "reached a terminal failure state: $response" >&2; exit 1 ;; esac\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in grading|completed) break ;; esac\n  [ "$(date +%s)" -ge "$deadline" ] && { echo "timed out waiting for a terminal state" >&2; exit 1; }\n  sleep 5\ndone\n\n# Wait for the first grade to finalize\ndeadline=$(( $(date +%s) + 900 ))\nwhile :; do\n  response=$(curl -s -X GET "https://api.recursion.labelbox.com/v1/problem-runs/$PROBLEM_RUN_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY")\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in failed|cancelled) echo "reached a terminal failure state: $response" >&2; exit 1 ;; esac\n  printf \'%s\' "$response" | jq -e \'.gradedAt != null\' >/dev/null && { break; }\n  [ "$(date +%s)" -ge "$deadline" ] && { echo "timed out waiting for a terminal state" >&2; exit 1; }\n  sleep 5\ndone\nINITIAL_SCORE=$(printf \'%s\' "$response" | jq -r \'.finalScore\')\n\n# Re-grade the run without re-running the solver\nREGRADE_JOB_V2_ID=$(curl -s -X POST "https://api.recursion.labelbox.com/v1/problem-runs/$PROBLEM_RUN_ID/regrade" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  | jq -r \'.jobV2Id\')\n\n# Wait for the re-grade to finish\ndeadline=$(( $(date +%s) + 900 ))\nwhile :; do\n  response=$(curl -s -X GET "https://api.recursion.labelbox.com/v1/environments/$ENVIRONMENT_ID/jobs-v2/$REGRADE_JOB_V2_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY")\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in failed|cancelled) echo "reached a terminal failure state: $response" >&2; exit 1 ;; esac\n  case "$(printf \'%s\' "$response" | jq -r \'.status\')" in completed) break ;; esac\n  [ "$(date +%s)" -ge "$deadline" ] && { echo "timed out waiting for a terminal state" >&2; exit 1; }\n  sleep 5\ndone\n\n# Read the new grade\nREGRADED_SCORE=$(curl -s -X GET "https://api.recursion.labelbox.com/v1/problem-runs/$PROBLEM_RUN_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  | jq -r \'.finalScore\')\n\n# Confirm the run records the re-grade\nREGRADE_COUNT=$(curl -s -X GET "https://api.recursion.labelbox.com/v1/problem-runs/$PROBLEM_RUN_ID" \\\n  -H "Authorization: Bearer $LABELBOX_API_KEY" \\\n  | jq -r \'.regradeCount\')',
+        },
+        related: {
+            requires: [
+                {
+                    type: 'state',
+                    explanation: 'a project with data rows exists to reserve a problem from',
+                    via: {
+                        type: 'recipe',
+                        id: 'create-a-project-with-data-rows',
+                    },
+                },
+            ],
+            learnMore: [
+                {
+                    type: 'concept',
+                    id: 're-grading-runs',
+                },
+                {
+                    type: 'concept',
+                    id: 'how-grading-works',
+                },
+            ],
+        },
+    },
     'remove-a-cost-limit': {
         id: 'remove-a-cost-limit',
         title: 'Remove a cost limit',

package/dist/reference/sdk-reference.generated.js

@@ -17613,8 +17613,8 @@ export const SDK_REFERENCE = {
                     name: 'maxImportFileSizeBytes',
                     required: true,
                     type: 'integer',
-                    description: 'Per-environment maximum import file size in bytes; null means the platform default is in effect.',
-                    example: 104857600,
+                    description: 'Platform import-file ceiling in bytes derived from the import worker memory limit; null means no platform ceiling is available.',
+                    example: 5726623061,
                     nullable: true,
                     exclusiveMinimum: 0,
                     maximum: 9007199254740991,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@labelbox/recursion-sdk",
-  "version": "0.0.171",
+  "version": "0.0.173",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",