@bolt-foundry/gambit 0.8.5 → 0.8.6-rc.2

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceBuildLiveWrite.js

@@ -0,0 +1,121 @@
+import { iso } from "../../__generated__/__isograph/iso.js";
+// This entrypoint exists to type/normalize external subscription writes.
+// NOTE: keep this rooted on Query for now. Isograph 0.5.x currently does not
+// emit full artifacts for Subscription entrypoints (missing entrypoint.ts),
+// which breaks generated route imports/codegen in this repo.
+export const EntrypointWorkspaceBuildLiveWrite = iso(`
+  field Query.EntrypointWorkspaceBuildLiveWrite($workspaceId: ID!) {
+    workspace(id: $workspaceId) {
+      id
+      scenarioDecks {
+        id
+        label
+        description
+        path
+        maxTurns
+      }
+      files(first: 200) {
+        edges {
+          node {
+            id
+            path
+            PreviewFile
+          }
+        }
+      }
+      buildRuns(first: 1) {
+        edges {
+          node {
+            id
+            status
+            openResponses(first: 1) {
+              edges {
+                node {
+                  id
+                  status
+                  outputItems(first: 200) {
+                    edges {
+                      node {
+                        __typename
+                        asOutputMessage {
+                          id
+                          role
+                          content
+                        }
+                        asOutputReasoning {
+                          id
+                          summary
+                          reasoningType
+                        }
+                        asOutputToolCall {
+                          id
+                          toolCallId
+                          toolName
+                          status
+                          argumentsText
+                          resultText
+                          error
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      scenarioRuns(first: 25) {
+        edges {
+          node {
+            id
+            status
+            startedAt
+            finishedAt
+            error
+            openResponses(first: 1) {
+              edges {
+                node {
+                  id
+                  status
+                  outputItems(first: 200) {
+                    edges {
+                      node {
+                        __typename
+                        asOutputMessage {
+                          id
+                          role
+                          content
+                        }
+                        asOutputReasoning {
+                          id
+                          summary
+                          reasoningType
+                        }
+                        asOutputToolCall {
+                          id
+                          toolCallId
+                          toolName
+                          status
+                          argumentsText
+                          resultText
+                          error
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`)(function EntrypointWorkspaceBuildLiveWrite() {
+    return {
+        Body: null,
+        title: "Gambit Simulator",
+    };
+});
+export default EntrypointWorkspaceBuildLiveWrite;

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceBuildTabLiveWrite.d.ts

@@ -0,0 +1,6 @@
+export declare const EntrypointWorkspaceBuildTabLiveWrite: (param: import("../../__generated__/__isograph/Query/EntrypointWorkspaceBuildTabLiveWrite/param_type.js").Query__EntrypointWorkspaceBuildTabLiveWrite__param) => {
+    Body: null;
+    title: string;
+};
+export default EntrypointWorkspaceBuildTabLiveWrite;
+//# sourceMappingURL=EntrypointWorkspaceBuildTabLiveWrite.d.ts.map

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceBuildTabLiveWrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntrypointWorkspaceBuildTabLiveWrite.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointWorkspaceBuildTabLiveWrite.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,oCAAoC;;;CAoB/C,CAAC;AAEH,eAAe,oCAAoC,CAAC"}

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceBuildTabLiveWrite.js

@@ -0,0 +1,27 @@
+import { iso } from "../../__generated__/__isograph/iso.js";
+// This entrypoint exists to type/normalize external subscription writes.
+// NOTE: keep this rooted on Query for now. Isograph 0.5.x currently does not
+// emit full artifacts for Subscription entrypoints (missing entrypoint.ts),
+// which breaks generated route imports/codegen in this repo.
+export const EntrypointWorkspaceBuildTabLiveWrite = iso(`
+  field Query.EntrypointWorkspaceBuildTabLiveWrite($workspaceId: ID!) {
+    workspace(id: $workspaceId) {
+      id
+      files(first: 200) {
+        edges {
+          node {
+            id
+            path
+            PreviewFile
+          }
+        }
+      }
+    }
+  }
+`)(function EntrypointWorkspaceBuildTabLiveWrite() {
+    return {
+        Body: null,
+        title: "Gambit Simulator",
+    };
+});
+export default EntrypointWorkspaceBuildTabLiveWrite;

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceGradeLiveWrite.d.ts

@@ -0,0 +1,6 @@
+export declare const EntrypointWorkspaceGradeLiveWrite: (param: import("../../__generated__/__isograph/Query/EntrypointWorkspaceGradeLiveWrite/param_type.js").Query__EntrypointWorkspaceGradeLiveWrite__param) => {
+    Body: null;
+    title: string;
+};
+export default EntrypointWorkspaceGradeLiveWrite;
+//# sourceMappingURL=EntrypointWorkspaceGradeLiveWrite.d.ts.map

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceGradeLiveWrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntrypointWorkspaceGradeLiveWrite.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointWorkspaceGradeLiveWrite.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,iCAAiC;;;CAgE5C,CAAC;AAEH,eAAe,iCAAiC,CAAC"}

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceGradeLiveWrite.js

@@ -0,0 +1,71 @@
+import { iso } from "../../__generated__/__isograph/iso.js";
+// This entrypoint exists to type/normalize external subscription writes.
+// NOTE: keep this rooted on Query for now. Isograph 0.5.x currently does not
+// emit full artifacts for Subscription entrypoints (missing entrypoint.ts),
+// which breaks generated route imports/codegen in this repo.
+export const EntrypointWorkspaceGradeLiveWrite = iso(`
+  field Query.EntrypointWorkspaceGradeLiveWrite($workspaceId: ID!) {
+    workspace(id: $workspaceId) {
+      id
+      scenarioRuns(first: 50) {
+        edges {
+          node {
+            id
+            status
+            startedAt
+            finishedAt
+            error
+          }
+        }
+      }
+      gradeTab {
+        graderDecks {
+          id
+          label
+          description
+          path
+        }
+        runs {
+          id
+          workspaceId
+          scenarioRunId
+          graderId
+          graderPath
+          graderLabel
+          status
+          runAt
+          error
+          summary {
+            score
+            reason
+          }
+          turns {
+            id
+            runId
+            turnIndex
+            turnNumber
+            refId
+            score
+            reason
+            priorUser
+            gradedAssistant
+          }
+        }
+        flags {
+          id
+          refId
+          runId
+          turnIndex
+          reason
+          createdAt
+        }
+      }
+    }
+  }
+`)(function EntrypointWorkspaceGradeLiveWrite() {
+    return {
+        Body: null,
+        title: "Gambit Simulator",
+    };
+});
+export default EntrypointWorkspaceGradeLiveWrite;

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceVerifyLiveWrite.d.ts

@@ -0,0 +1,6 @@
+export declare const EntrypointWorkspaceVerifyLiveWrite: (param: import("../../__generated__/__isograph/Query/EntrypointWorkspaceVerifyLiveWrite/param_type.js").Query__EntrypointWorkspaceVerifyLiveWrite__param) => {
+    Body: null;
+    title: string;
+};
+export default EntrypointWorkspaceVerifyLiveWrite;
+//# sourceMappingURL=EntrypointWorkspaceVerifyLiveWrite.d.ts.map

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceVerifyLiveWrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntrypointWorkspaceVerifyLiveWrite.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointWorkspaceVerifyLiveWrite.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,kCAAkC;;;CAyG7C,CAAC;AAEH,eAAe,kCAAkC,CAAC"}

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceVerifyLiveWrite.js

@@ -0,0 +1,112 @@
+import { iso } from "../../__generated__/__isograph/iso.js";
+// This entrypoint exists to type/normalize external subscription writes.
+// NOTE: keep this rooted on Query for now. Isograph 0.5.x currently does not
+// emit full artifacts for Subscription entrypoints (missing entrypoint.ts),
+// which breaks generated route imports/codegen in this repo.
+export const EntrypointWorkspaceVerifyLiveWrite = iso(`
+  field Query.EntrypointWorkspaceVerifyLiveWrite($workspaceId: ID!) {
+    workspace(id: $workspaceId) {
+      id
+      scenarioDecks {
+        id
+        label
+        description
+        path
+      }
+      verification {
+        graderDecks(first: 50) {
+          edges {
+            node {
+              id
+              label
+              description
+              path
+            }
+          }
+        }
+        batches(first: 50) {
+          edges {
+            node {
+              id
+              workspaceId
+              scenarioDeckId
+              graderId
+              scenarioRuns
+              graderRepeatsPerScenario
+              status
+              startedAt
+              finishedAt
+              requested
+              active
+              completed
+              failed
+              scenarioRunsCompleted
+              scenarioRunsFailed
+              requests(first: 200) {
+                edges {
+                  node {
+                    id
+                    scenarioRunId
+                    status
+                    runId
+                    error
+                  }
+                }
+              }
+              metrics {
+                scenarioRunCountRequested
+                scenarioRunCountCompleted
+                scenarioRunCountFailed
+                gradeSampleCountRequested
+                gradeSampleCountCompleted
+                gradeSampleCountFailed
+                executionFailureCount
+                gradingFailureCount
+                passRate
+                scoreMin
+                scoreMedian
+                scoreMax
+                scoreMean
+                outlierScenarioRuns(first: 25) {
+                  edges {
+                    node {
+                      key
+                      scenarioRunId
+                      gradeSampleCount
+                      completedSampleCount
+                      executionFailureCount
+                      gradingFailureCount
+                      averageScore
+                      minScore
+                      maxScore
+                      failed
+                      minRunId
+                      maxRunId
+                      messageRefId
+                    }
+                  }
+                }
+                failureReasons(first: 25) {
+                  edges {
+                    node {
+                      key
+                      kind
+                      reason
+                      count
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`)(function EntrypointWorkspaceVerifyLiveWrite() {
+    return {
+        Body: null,
+        title: "Gambit Simulator",
+    };
+});
+export default EntrypointWorkspaceVerifyLiveWrite;

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceWorkbenchLiveWrite.d.ts

@@ -0,0 +1,6 @@
+export declare const EntrypointWorkspaceWorkbenchLiveWrite: (param: import("../../__generated__/__isograph/Query/EntrypointWorkspaceWorkbenchLiveWrite/param_type.js").Query__EntrypointWorkspaceWorkbenchLiveWrite__param) => {
+    Body: null;
+    title: string;
+};
+export default EntrypointWorkspaceWorkbenchLiveWrite;
+//# sourceMappingURL=EntrypointWorkspaceWorkbenchLiveWrite.d.ts.map

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceWorkbenchLiveWrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntrypointWorkspaceWorkbenchLiveWrite.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointWorkspaceWorkbenchLiveWrite.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,qCAAqC;;;CA+BhD,CAAC;AAEH,eAAe,qCAAqC,CAAC"}

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceWorkbenchLiveWrite.js

@@ -0,0 +1,38 @@
+import { iso } from "../../__generated__/__isograph/iso.js";
+// This entrypoint exists to type/normalize external subscription writes.
+// NOTE: keep this rooted on Query for now. Isograph 0.5.x currently does not
+// emit full artifacts for Subscription entrypoints (missing entrypoint.ts),
+// which breaks generated route imports/codegen in this repo.
+export const EntrypointWorkspaceWorkbenchLiveWrite = iso(`
+  field Query.EntrypointWorkspaceWorkbenchLiveWrite($workspaceId: ID!) {
+    workspace(id: $workspaceId) {
+      id
+      models {
+        codex {
+          model
+          workspaceId
+          available
+          requiresLogin
+          loggedIn
+          statusText
+          trustedPath
+          writeEnabled
+        }
+      }
+      buildRuns(first: 1) {
+        edges {
+          node {
+            id
+            WorkbenchConversationRunChat
+          }
+        }
+      }
+    }
+  }
+`)(function EntrypointWorkspaceWorkbenchLiveWrite() {
+    return {
+        Body: null,
+        title: "Gambit Simulator",
+    };
+});
+export default EntrypointWorkspaceWorkbenchLiveWrite;

package/esm/simulator-ui/mutations/GambitSimulatorStopRun.d.ts

@@ -0,0 +1,87 @@
+export declare const GambitSimulatorStopRunMutation: (param: import("../__generated__/__isograph/Mutation/GambitSimulatorStopRun/param_type.js").Mutation__GambitSimulatorStopRun__param) => {
+    readonly workspace: ({
+        readonly id: (string | null);
+        readonly buildRuns: ({
+            readonly edges: (ReadonlyArray<({
+                readonly node: ({
+                    readonly id: (string | null);
+                    readonly status: (string | null);
+                    readonly openResponses: ({
+                        readonly edges: (ReadonlyArray<({
+                            readonly node: ({
+                                readonly id: (string | null);
+                                readonly status: (string | null);
+                                readonly outputItems: ({
+                                    readonly edges: (ReadonlyArray<({
+                                        readonly node: ({
+                                            readonly __typename: string;
+                                            readonly asOutputMessage: ({
+                                                readonly id: (string | null);
+                                                readonly role: (string | null);
+                                                readonly content: (string | null);
+                                            } | null);
+                                            readonly asOutputReasoning: ({
+                                                readonly id: (string | null);
+                                                readonly summary: (string | null);
+                                                readonly reasoningType: (string | null);
+                                            } | null);
+                                            readonly asOutputToolCall: ({
+                                                readonly id: (string | null);
+                                                readonly toolCallId: (string | null);
+                                                readonly toolName: (string | null);
+                                                readonly status: (string | null);
+                                                readonly argumentsText: (string | null);
+                                                readonly resultText: (string | null);
+                                                readonly error: (string | null);
+                                            } | null);
+                                        } | null);
+                                    } | null)> | null);
+                                } | null);
+                            } | null);
+                        } | null)> | null);
+                    } | null);
+                } | null);
+            } | null)> | null);
+        } | null);
+    } | null);
+    readonly run: ({
+        readonly id: (string | null);
+        readonly status: (string | null);
+        readonly openResponses: ({
+            readonly edges: (ReadonlyArray<({
+                readonly node: ({
+                    readonly id: (string | null);
+                    readonly status: (string | null);
+                    readonly outputItems: ({
+                        readonly edges: (ReadonlyArray<({
+                            readonly node: ({
+                                readonly __typename: string;
+                                readonly asOutputMessage: ({
+                                    readonly id: (string | null);
+                                    readonly role: (string | null);
+                                    readonly content: (string | null);
+                                } | null);
+                                readonly asOutputReasoning: ({
+                                    readonly id: (string | null);
+                                    readonly summary: (string | null);
+                                    readonly reasoningType: (string | null);
+                                } | null);
+                                readonly asOutputToolCall: ({
+                                    readonly id: (string | null);
+                                    readonly toolCallId: (string | null);
+                                    readonly toolName: (string | null);
+                                    readonly status: (string | null);
+                                    readonly argumentsText: (string | null);
+                                    readonly resultText: (string | null);
+                                    readonly error: (string | null);
+                                } | null);
+                            } | null);
+                        } | null)> | null);
+                    } | null);
+                } | null);
+            } | null)> | null);
+        } | null);
+    } | null);
+} | null;
+export default GambitSimulatorStopRunMutation;
+//# sourceMappingURL=GambitSimulatorStopRun.d.ts.map

package/esm/simulator-ui/mutations/GambitSimulatorStopRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GambitSimulatorStopRun.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/mutations/GambitSimulatorStopRun.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4FzC,CAAC;AAEH,eAAe,8BAA8B,CAAC"}

package/esm/simulator-ui/mutations/GambitSimulatorStopRun.js

@@ -0,0 +1,95 @@
+import { iso } from "../__generated__/__isograph/iso.js";
+export const GambitSimulatorStopRunMutation = iso(`
+  field Mutation.GambitSimulatorStopRun(
+    $input: SimulatorStopRunInput!
+  ) {
+    simulatorStopRun(input: $input) {
+      workspace {
+        id
+        buildRuns(first: 1) {
+          edges {
+            node {
+              id
+              status
+              openResponses(first: 1) {
+                edges {
+                  node {
+                    id
+                    status
+                    outputItems(first: 200) {
+                      edges {
+                        node {
+                          __typename
+                          asOutputMessage {
+                            id
+                            role
+                            content
+                          }
+                          asOutputReasoning {
+                            id
+                            summary
+                            reasoningType
+                          }
+                          asOutputToolCall {
+                            id
+                            toolCallId
+                            toolName
+                            status
+                            argumentsText
+                            resultText
+                            error
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      run {
+        id
+        status
+        openResponses(first: 1) {
+          edges {
+            node {
+              id
+              status
+              outputItems(first: 200) {
+                edges {
+                  node {
+                    __typename
+                    asOutputMessage {
+                      id
+                      role
+                      content
+                    }
+                    asOutputReasoning {
+                      id
+                      summary
+                      reasoningType
+                    }
+                    asOutputToolCall {
+                      id
+                      toolCallId
+                      toolName
+                      status
+                      argumentsText
+                      resultText
+                      error
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`)(function GambitSimulatorStopRun({ data }) {
+    return data.simulatorStopRun;
+});
+export default GambitSimulatorStopRunMutation;