@bolt-foundry/gambit 0.8.6-rc.4 → 0.8.6-rc.6

package/esm/src/simulator_graphql.js

@@ -18,6 +18,116 @@ function logBuildChatDebug(event, payload) {
     // deno-lint-ignore no-console -- debug logging is gated by env var.
     console.log(`[gambit-build-chat-debug] ${event} ${JSON.stringify(payload)}`);
 }
+function toTranscriptMessageRole(value) {
+    return value === "user" ? "user" : "assistant";
+}
+function isTranscriptMessageFeedbackEligible(message) {
+    if (typeof message.feedbackEligible === "boolean") {
+        return message.feedbackEligible;
+    }
+    const role = toTranscriptMessageRole(message.role);
+    return role === "assistant" ||
+        (role === "user" && message.messageSource === "scenario");
+}
+function buildTranscriptMessages(parent) {
+    return parent.messages.map((message, index) => ({
+        __typename: "WorkspaceConversationTranscriptMessage",
+        id: message.messageRefId ?? `${parent.id}:transcript:${index}`,
+        role: toTranscriptMessageRole(message.role),
+        content: message.content,
+        messageRefId: message.messageRefId,
+        feedbackEligible: isTranscriptMessageFeedbackEligible(message),
+        feedback: message.feedback,
+    }));
+}
+function buildTranscriptEntries(args) {
+    const transcriptMessages = buildTranscriptMessages(args.parent);
+    if (args.outputItems.length === 0) {
+        return transcriptMessages;
+    }
+    const transcriptEntries = [];
+    const consumedCanonicalMessageIndexes = new Set();
+    let messageCursor = 0;
+    const markCanonicalMessageConsumed = (index) => {
+        consumedCanonicalMessageIndexes.add(index);
+        while (messageCursor < transcriptMessages.length &&
+            consumedCanonicalMessageIndexes.has(messageCursor)) {
+            messageCursor += 1;
+        }
+        return transcriptMessages[index];
+    };
+    const toTranscriptEntryFromOutputItem = (item) => {
+        switch (item.__typename) {
+            case "OutputReasoning":
+                return {
+                    __typename: "WorkspaceConversationTranscriptReasoning",
+                    id: item.id,
+                    summary: item.summary,
+                    reasoningType: item.reasoningType,
+                };
+            case "OutputToolCall":
+                return {
+                    __typename: "WorkspaceConversationTranscriptToolCall",
+                    id: item.id,
+                    toolCallId: item.toolCallId,
+                    toolName: item.toolName,
+                    status: item.status,
+                    argumentsText: item.argumentsText,
+                    resultText: item.resultText,
+                    error: item.error,
+                };
+            case "OutputMessage":
+                return {
+                    __typename: "WorkspaceConversationTranscriptMessage",
+                    id: item.messageRefId ?? item.id,
+                    role: toTranscriptMessageRole(item.role),
+                    content: item.content,
+                    messageRefId: item.messageRefId,
+                    feedbackEligible: item.feedbackEligible,
+                    feedback: item.feedback,
+                };
+        }
+    };
+    const takeCanonicalMessageForOutput = (item) => {
+        if (item.messageRefId) {
+            for (let index = messageCursor; index < transcriptMessages.length; index += 1) {
+                const message = transcriptMessages[index];
+                if (!consumedCanonicalMessageIndexes.has(index) &&
+                    message.messageRefId === item.messageRefId) {
+                    return markCanonicalMessageConsumed(index);
+                }
+            }
+        }
+        for (let index = messageCursor; index < transcriptMessages.length; index += 1) {
+            const message = transcriptMessages[index];
+            if (!consumedCanonicalMessageIndexes.has(index) &&
+                message.role === toTranscriptMessageRole(item.role) &&
+                message.content.trim() === item.content.trim()) {
+                return markCanonicalMessageConsumed(index);
+            }
+        }
+        return null;
+    };
+    for (const item of args.outputItems) {
+        if (item.__typename === "OutputMessage") {
+            transcriptEntries.push(takeCanonicalMessageForOutput(item) ??
+                toTranscriptEntryFromOutputItem(item));
+            continue;
+        }
+        const entry = toTranscriptEntryFromOutputItem(item);
+        if (entry) {
+            transcriptEntries.push(entry);
+        }
+    }
+    if (args.parent.conversationRunKind === "scenario") {
+        for (let index = 0; index < transcriptMessages.length; index += 1) {
+            if (consumedCanonicalMessageIndexes.has(index))
+                continue;
+            transcriptEntries.push(transcriptMessages[index]);
+        }
+    }
+    return transcriptEntries;
+}
 const builder = new SchemaBuilder({
     plugins: [RelayPlugin],
     relay: {},
@@ -296,6 +406,17 @@ WorkspaceRunInterface.implement({
         }),
     }),
 });
+const TranscriptMessageType = builder.objectRef("WorkspaceConversationTranscriptMessage");
+const TranscriptReasoningType = builder.objectRef("WorkspaceConversationTranscriptReasoning");
+const TranscriptToolCallType = builder.objectRef("WorkspaceConversationTranscriptToolCall");
+const WorkspaceConversationTranscriptEntryType = builder.unionType("WorkspaceConversationTranscriptEntry", {
+    types: [
+        TranscriptMessageType,
+        TranscriptReasoningType,
+        TranscriptToolCallType,
+    ],
+    resolveType: (parent) => parent.__typename,
+});
 const WorkspaceConversationRunInterface = builder.interfaceRef("WorkspaceConversationRun");
 WorkspaceConversationRunInterface.implement({
     resolveType: (parent) => parent.conversationRunKind === "scenario"
@@ -324,6 +445,23 @@ WorkspaceConversationRunInterface.implement({
             nullable: true,
             resolve: (parent) => parent.finishedAt ?? null,
         }),
+        transcriptEntries: t.field({
+            type: [WorkspaceConversationTranscriptEntryType],
+            resolve: async (parent, _args, ctx) => {
+                const workspaceId = typeof parent.workspaceId === "string" &&
+                    parent.workspaceId.trim().length > 0
+                    ? parent.workspaceId
+                    : null;
+                if (!workspaceId || !ctx.readWorkspaceOpenResponseOutputItems) {
+                    return buildTranscriptMessages(parent);
+                }
+                const outputItems = await ctx.readWorkspaceOpenResponseOutputItems({
+                    workspaceId,
+                    runId: parent.id,
+                });
+                return buildTranscriptEntries({ parent, outputItems });
+            },
+        }),
         openResponses: t.connection({
             type: OpenResponseType,
             args: {
@@ -359,6 +497,58 @@ FeedbackType.implement({
         }),
     }),
 });
+TranscriptMessageType.implement({
+    fields: (t) => ({
+        id: t.id({ resolve: (parent) => parent.id }),
+        role: t.string({ resolve: (parent) => parent.role }),
+        content: t.string({ resolve: (parent) => parent.content }),
+        messageRefId: t.id({
+            nullable: true,
+            resolve: (parent) => parent.messageRefId ?? null,
+        }),
+        feedbackEligible: t.boolean({
+            resolve: (parent) => parent.feedbackEligible,
+        }),
+        feedback: t.field({
+            type: FeedbackType,
+            nullable: true,
+            resolve: (parent) => parent.feedback ?? null,
+        }),
+    }),
+});
+TranscriptReasoningType.implement({
+    fields: (t) => ({
+        id: t.id({ resolve: (parent) => parent.id }),
+        summary: t.string({ resolve: (parent) => parent.summary }),
+        reasoningType: t.string({
+            nullable: true,
+            resolve: (parent) => parent.reasoningType ?? null,
+        }),
+    }),
+});
+TranscriptToolCallType.implement({
+    fields: (t) => ({
+        id: t.id({ resolve: (parent) => parent.id }),
+        toolCallId: t.id({ resolve: (parent) => parent.toolCallId }),
+        toolName: t.string({ resolve: (parent) => parent.toolName }),
+        status: t.field({
+            type: ToolCallStatusEnum,
+            resolve: (parent) => parent.status,
+        }),
+        argumentsText: t.string({
+            nullable: true,
+            resolve: (parent) => parent.argumentsText ?? null,
+        }),
+        resultText: t.string({
+            nullable: true,
+            resolve: (parent) => parent.resultText ?? null,
+        }),
+        error: t.string({
+            nullable: true,
+            resolve: (parent) => parent.error ?? null,
+        }),
+    }),
+});
 const OutputMessageType = builder.objectRef("OutputMessage");
 OutputMessageType.implement({
     fields: (t) => ({
@@ -369,6 +559,9 @@ OutputMessageType.implement({
             nullable: true,
             resolve: (parent) => parent.messageRefId ?? null,
         }),
+        feedbackEligible: t.boolean({
+            resolve: (parent) => parent.feedbackEligible,
+        }),
         feedback: t.field({
             type: FeedbackType,
             nullable: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolt-foundry/gambit",
-  "version": "0.8.6-rc.4",
+  "version": "0.8.6-rc.6",
   "description": "Agent harness framework for building, running, and verifying LLM workflows in Markdown and code.",
   "homepage": "https://github.com/bolt-foundry/gambit",
   "repository": {