@runtypelabs/sdk 5.8.0 → 5.9.0

package/dist/index.d.cts

@@ -645,7 +645,7 @@ interface paths {
                             /** @enum {string} */
                             setupMode: "create" | "connect";
                             systemPrompt?: string;
-                            timeoutMs?: number;
+                            timeoutMs?: number | null;
                             toolPermissions?: {
                                 bash?: boolean;
                                 edit?: boolean;
@@ -1723,7 +1723,7 @@ interface paths {
                             /** @enum {string} */
                             setupMode?: "create" | "connect";
                             systemPrompt?: string;
-                            timeoutMs?: number;
+                            timeoutMs?: number | null;
                             toolPermissions?: {
                                 bash?: boolean;
                                 edit?: boolean;
@@ -7090,6 +7090,10 @@ interface paths {
                     };
                     content: {
                         "application/json": {
+                            /** @description Present only for Runtype App data-plane sessions: the owning app id. Such sessions authorize `/v1/client/records` but cannot dispatch chat. */
+                            app?: {
+                                id: string;
+                            };
                             config: {
                                 placeholder?: string;
                                 theme?: unknown;
@@ -7097,7 +7101,8 @@ interface paths {
                             };
                             /** @description ISO-8601 session idle-expiry timestamp. */
                             expiresAt: string;
-                            flow: {
+                            /** @description Resolved flow/agent for this session. Omitted for data-only Runtype App sessions whose manifest declares record namespaces but no flow or agent (the `app` field is present instead). */
+                            flow?: {
                                 description?: string | null;
                                 /** @description Resolved flow or agent ID for this session. */
                                 id: string;
@@ -7161,6 +7166,548 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/client/records": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List app records in a namespace
+         * @description List records in a granted namespace for a Runtype App data-plane session, newest first, cursor-paginated. The namespace must be declared in the app manifest (`data[]`).
+         */
+        get: {
+            parameters: {
+                query: {
+                    /** @description Client session id from /client/init. */
+                    sessionId: string;
+                    /** @description The record namespace to list. */
+                    namespace: string;
+                    cursor?: string;
+                    limit?: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Records page */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: {
+                                createdAt: string;
+                                /** @description Record id. */
+                                id: string;
+                                /** @description Caller-defined record fields. Server provenance is never echoed here. */
+                                metadata: {
+                                    [key: string]: unknown;
+                                };
+                                /** @description Record name (unique per namespace within the tenant). */
+                                name: string;
+                                /** @description The record namespace (record `type`). */
+                                namespace: string;
+                                updatedAt: string;
+                            }[];
+                            /** @description Opaque cursor for the next page, or null when exhausted. */
+                            nextCursor: string | null;
+                        };
+                    };
+                };
+                /** @description Validation error */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Session not found or expired */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Not an app token, origin mismatch, or namespace not granted */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description App has no active version */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Create an app record
+         * @description Create a record in a granted namespace from a Runtype App data-plane session. The namespace must have `read-write` access in the app manifest. Provenance (app, version, session) is stamped server-side.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /** @default {} */
+                        metadata?: {
+                            [key: string]: unknown;
+                        };
+                        name?: string;
+                        namespace: string;
+                        sessionId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Record created */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            createdAt: string;
+                            /** @description Record id. */
+                            id: string;
+                            /** @description Caller-defined record fields. Server provenance is never echoed here. */
+                            metadata: {
+                                [key: string]: unknown;
+                            };
+                            /** @description Record name (unique per namespace within the tenant). */
+                            name: string;
+                            /** @description The record namespace (record `type`). */
+                            namespace: string;
+                            updatedAt: string;
+                        };
+                    };
+                };
+                /** @description Validation error or metadata too large */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Session not found or expired */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Not an app token, origin mismatch, namespace not writable, or per-app record cap reached */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description App has no active version, or duplicate record name */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Write rate limit exceeded (per app or per session) */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/client/records/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get an app record
+         * @description Fetch a single record by id for a Runtype App data-plane session. The record must belong to the app owner and live in a granted namespace.
+         */
+        get: {
+            parameters: {
+                query: {
+                    sessionId: string;
+                };
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Record */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            createdAt: string;
+                            /** @description Record id. */
+                            id: string;
+                            /** @description Caller-defined record fields. Server provenance is never echoed here. */
+                            metadata: {
+                                [key: string]: unknown;
+                            };
+                            /** @description Record name (unique per namespace within the tenant). */
+                            name: string;
+                            /** @description The record namespace (record `type`). */
+                            namespace: string;
+                            updatedAt: string;
+                        };
+                    };
+                };
+                /** @description Validation error */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Session not found or expired */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Not an app token, origin mismatch, or namespace not granted */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Record not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description App has no active version */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        /**
+         * Update an app record
+         * @description Update a record's metadata and/or name from a Runtype App data-plane session. The record's namespace must have `read-write` access. Server provenance is preserved. PUT is a full metadata replace. Pass `expectedUpdatedAt` (the `updatedAt` from your last read) for optimistic concurrency: a stale token is rejected with 409 and the current record so concurrent writers don't silently clobber each other.
+         */
+        put: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /**
+                         * Format: date-time
+                         * @description Optional optimistic-concurrency token. Pass the `updatedAt` from your last read; the update is rejected with 409 (and the current record) if the stored record has changed since. Omit for last-write-wins.
+                         */
+                        expectedUpdatedAt?: string;
+                        metadata?: {
+                            [key: string]: unknown;
+                        };
+                        name?: string;
+                        sessionId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Updated record */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            createdAt: string;
+                            /** @description Record id. */
+                            id: string;
+                            /** @description Caller-defined record fields. Server provenance is never echoed here. */
+                            metadata: {
+                                [key: string]: unknown;
+                            };
+                            /** @description Record name (unique per namespace within the tenant). */
+                            name: string;
+                            /** @description The record namespace (record `type`). */
+                            namespace: string;
+                            updatedAt: string;
+                        };
+                    };
+                };
+                /** @description Validation error or metadata too large */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Session not found or expired */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Not an app token, origin mismatch, or namespace not writable */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Record not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description App has no active version, duplicate record name, or an optimistic-concurrency conflict (`expectedUpdatedAt` is stale — body carries the current record). */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                            hint?: string;
+                            /** @description The current server record (present on an optimistic-concurrency conflict). */
+                            record?: {
+                                createdAt: string;
+                                /** @description Record id. */
+                                id: string;
+                                /** @description Caller-defined record fields. Server provenance is never echoed here. */
+                                metadata: {
+                                    [key: string]: unknown;
+                                };
+                                /** @description Record name (unique per namespace within the tenant). */
+                                name: string;
+                                /** @description The record namespace (record `type`). */
+                                namespace: string;
+                                updatedAt: string;
+                            };
+                        };
+                    };
+                };
+                /** @description Write rate limit exceeded (per app or per session) */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        post?: never;
+        /**
+         * Delete an app record
+         * @description Delete a record by id from a Runtype App data-plane session. The record must belong to the app owner and its namespace must have `read-write` access.
+         */
+        delete: {
+            parameters: {
+                query: {
+                    sessionId: string;
+                };
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Record deleted */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Validation error */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Session not found or expired */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Not an app token, origin mismatch, or namespace not writable */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Record not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description App has no active version */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Write rate limit exceeded (per app or per session) */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/client/resume": {
         parameters: {
             query?: never;
@@ -9541,6 +10088,8 @@ interface paths {
                     status?: string;
                     /** @description Filter by run origin: "suite" = runs linked to an eval suite (CI gates, suite Run button); "adhoc" = suite-less runs (ad-hoc config comparisons, legacy evals). */
                     origin?: "suite" | "adhoc";
+                    /** @description Filter to runs of a specific eval suite. Server-side, so a suite with sparse runs is not crowded out of the page by other suites. */
+                    evalSuiteId?: string;
                 };
                 header?: never;
                 path?: never;
@@ -9559,6 +10108,8 @@ interface paths {
                                 [key: string]: unknown;
                             }[];
                             count: number;
+                            /** @description True when this page came back full — there may be more rows past it. */
+                            hasMore: boolean;
                             limit: number;
                             offset: number;
                         };
@@ -10606,6 +11157,11 @@ interface paths {
                             };
                             name: string;
                             notes?: string;
+                            /**
+                             * @description Case provenance. Defaults to "manual" when omitted.
+                             * @enum {string}
+                             */
+                            origin?: "manual" | "saved_from_run" | "generated" | "imported" | "fpo";
                         }[];
                         description?: string;
                         flowId?: string;
@@ -10956,6 +11512,11 @@ interface paths {
                             };
                             name: string;
                             notes?: string;
+                            /**
+                             * @description Case provenance. Defaults to "manual" when omitted.
+                             * @enum {string}
+                             */
+                            origin?: "manual" | "saved_from_run" | "generated" | "imported" | "fpo";
                         }[];
                     };
                 };
@@ -17843,6 +18404,8 @@ interface paths {
                     content: {
                         "application/json": {
                             data: {
+                                /** @description True when historical (R2 SQL) logs were unavailable and only recent hot-tier entries are included. Absent on healthy responses. */
+                                degraded?: boolean;
                                 entries: {
                                     [key: string]: unknown;
                                 }[];
@@ -18021,6 +18584,8 @@ interface paths {
                                 byType: {
                                     [key: string]: number;
                                 };
+                                /** @description True when historical (R2 SQL) counts were unavailable and stats cover only the recent hot-tier window. Absent on healthy responses. */
+                                degraded?: boolean;
                                 histogram: {
                                     bucket: string;
                                     count: number;
@@ -38156,6 +38721,12 @@ interface components {
                 caseId: string | null;
                 name: string;
                 outcomes: {
+                    /** @description AI graders only: transcript entries the verdict rests on — indices into the run's trace steps (message) or tool calls (tool_call). */
+                    evidence?: {
+                        index: number;
+                        /** @enum {string} */
+                        kind: "message" | "tool_call";
+                    }[];
                     graderIndex: number;
                     kind: string;
                     passed: boolean;
@@ -38166,6 +38737,11 @@ interface components {
                      * @enum {string}
                      */
                     severity?: "gate" | "soft";
+                    /**
+                     * @description AI graders only: the judge's binary verdict. insufficient_evidence means the judge declined to guess; it renders as a warning and never fails the case.
+                     * @enum {string}
+                     */
+                    verdict?: "pass" | "fail" | "insufficient_evidence";
                 }[];
                 /** @description Truncated snapshot of the output that was graded (2000 chars max). */
                 outputExcerpt: string;
@@ -39275,6 +39851,12 @@ interface components {
                 errored: boolean;
                 name: string;
                 outcomes: {
+                    /** @description AI graders only: transcript entries the verdict rests on — indices into the run's trace steps (message) or tool calls (tool_call). */
+                    evidence?: {
+                        index: number;
+                        /** @enum {string} */
+                        kind: "message" | "tool_call";
+                    }[];
                     graderIndex: number;
                     kind: string;
                     passed: boolean;
@@ -39285,6 +39867,11 @@ interface components {
                      * @enum {string}
                      */
                     severity?: "gate" | "soft";
+                    /**
+                     * @description AI graders only: the judge's binary verdict. insufficient_evidence means the judge declined to guess; it renders as a warning and never fails the case.
+                     * @enum {string}
+                     */
+                    verdict?: "pass" | "fail" | "insufficient_evidence";
                 }[];
                 outputExcerpt: string;
                 passed: boolean;
@@ -41835,6 +42422,8 @@ interface LogQueryResult {
         cursor: string | null;
         hasMore: boolean;
     };
+    /** True when historical (R2 SQL) logs were unavailable and only recent hot-tier entries are included. */
+    degraded?: boolean;
 }
 /** Logs are wrapped in a `{ success, data }` envelope by the API. */
 interface LogQueryResponse {
@@ -41853,6 +42442,8 @@ interface LogStatsResult {
         count: number;
         errors: number;
     }>;
+    /** True when historical (R2 SQL) counts were unavailable and stats cover only the recent hot-tier window. */
+    degraded?: boolean;
 }
 interface LogStatsResponse {
     success: boolean;
@@ -42060,8 +42651,17 @@ interface AIGrader {
     criteria: string;
     /** Reference-guided when the case has `expected`. */
     useExpected?: boolean;
-    /** Defaults to a cheap routed model at execution time. */
+    /** Defaults to a cheap routed model at execution time. Ignored when `judgeFlowId` is set. */
     model?: string;
+    /**
+     * Custom judge flow: your flow (by id) runs as the judge instead of the
+     * platform judge prompt. It receives `criteria`, `caseName`, `expected`, and
+     * `transcript` as inputs and must output the platform verdict JSON
+     * (`{"reasoning", "verdict": "pass"|"fail"|"insufficient_evidence", "evidence"}`).
+     * A miswired flow (missing, failing, or returning malformed output) resolves
+     * to an insufficient-evidence warning with the error, never a verdict.
+     */
+    judgeFlowId?: string;
     /** Pass cutoff on the 1-5 judge scale (default 4 server-side). Set via `.atLeast(n)`. */
     threshold?: number;
     /** Hard gate (default) vs soft. Set via `.gate()` / `.soft()`. */
@@ -42156,6 +42756,7 @@ declare function cost(maxUsd: number): Gradeable<CheckGrader>;
 declare function judge(criteria: string, opts?: {
     useExpected?: boolean;
     model?: string;
+    judgeFlowId?: string;
     threshold?: number;
     preset?: BuiltInGraderId;
 }): Gradeable<AIGrader>;
@@ -42291,10 +42892,24 @@ interface GraderOutcome {
     passed: boolean;
     /** The grader's severity (absent ⇒ gate). A soft miss only fails under `--strict`. */
     severity?: GraderSeverity;
-    /** 0..1 for scaled graders (AI graders normalize their 1-5 to 0..1). */
+    /** 0..1 for scaled graders (AI graders normalize their 1-5 to 0..1). Absent for `insufficient_evidence`. */
     score?: number;
-    /** AI-grader verdict, or a check's human-readable reason. */
+    /** AI-grader reasoning (critique-before-verdict), or a check's human-readable reason. */
     reasoning?: string;
+    /**
+     * AI graders only: the trajectory judge's binary verdict.
+     * `insufficient_evidence` means the judge declined to guess — it renders as
+     * a warning and never fails the case.
+     */
+    verdict?: 'pass' | 'fail' | 'insufficient_evidence';
+    /**
+     * AI graders only: transcript entries the verdict rests on — indices into
+     * the run's trace steps (`message`) or tool calls (`tool_call`).
+     */
+    evidence?: Array<{
+        kind: 'message' | 'tool_call';
+        index: number;
+    }>;
 }
 /** One case's run result: pass/fail plus each grader's outcome. */
 interface RunEvalCaseResult {
@@ -43164,6 +43779,8 @@ interface EvalSuiteCase {
 interface EvalSuiteDetail extends EvalSuiteSummary {
     cases: EvalSuiteCase[];
 }
+/** Case provenance (mirror of `EvalCaseOrigin` in `@runtypelabs/shared`). */
+type EvalCaseOrigin = 'manual' | 'saved_from_run' | 'generated' | 'imported' | 'fpo';
 /** One case to create. */
 interface EvalSuiteCaseInput {
     name: string;
@@ -43171,6 +43788,8 @@ interface EvalSuiteCaseInput {
     expected?: CaseExpected;
     notes?: string;
     enabled?: boolean;
+    /** Case provenance. Defaults to 'manual' server-side when omitted. */
+    origin?: EvalCaseOrigin;
 }
 /** Input to `client.evals.suites.create`. Exactly one of flowId/agentId. */
 interface CreateEvalSuiteInput {