@sixb/core 0.1.2 → 0.1.4

package/src/agents/adapters.ts

@@ -8,7 +8,9 @@ import {
 } from "./context"
 import { serializeAgentContextForModel } from "./context-model"
 import { AgentMessageAdapterError } from "./errors"
-import type { AgentMessage, AgentMessagePart, AgentMessageRole } from "./message"
+import type { AgentMessage, AgentMessagePart, AgentMessageRole, AgentToolCallPart } from "./message"
+import { isAgentToolResult } from "./tool-result"
+import type { AgentToolFileContent } from "./types"
 
 // ── Inbound (write) — deliberately WIDE ────────────────────────────────────────────────────────
 //
@@ -159,6 +161,14 @@ export interface AgentFileDataProjection {
   readonly filename?: string
 }
 
+export interface AgentToolResultFileResolverInput<TMessage extends AgentMessage = AgentMessage> {
+  readonly message: TMessage
+  readonly part: AgentToolCallPart
+  readonly partIndex: number
+  readonly contentPart: AgentToolFileContent
+  readonly contentIndex: number
+}
+
 export interface ToModelMessagesOptions<TMessage extends AgentMessage = AgentMessage> {
   /**
    * Convert a stored file reference into model-readable data. When omitted, file parts are skipped
@@ -173,6 +183,10 @@ export interface ToModelMessagesOptions<TMessage extends AgentMessage = AgentMes
    * models that cannot consume inline files.
    */
   readonly fileText?: (input: AgentFileDataResolverInput<TMessage>) => string | undefined
+  /** Add current metadata, sandbox paths, and projection notes for a tool-result file. */
+  readonly toolResultFileText?: (
+    input: AgentToolResultFileResolverInput<TMessage>
+  ) => string | undefined
 }
 
 // ── Helpers ─────────────────────────────────────────────────────────────────────────────────────
@@ -337,7 +351,7 @@ function fromUiContextPart(part: AgentInboundUiMessagePart): AgentMessagePart {
   }
 }
 
-function fromAiSdkToolPart(part: AgentInboundUiMessagePart): AgentToolCallPartResult {
+function fromAiSdkToolPart(part: AgentInboundUiMessagePart): AgentToolCallPart {
   const dynamic = part.type === "dynamic-tool"
   const toolName = toolNameFromInbound(part)
   assertAdapter(
@@ -373,8 +387,6 @@ function fromAiSdkToolPart(part: AgentInboundUiMessagePart): AgentToolCallPartRe
   return { ...base, state: "output-error", errorText: part.errorText }
 }
 
-type AgentToolCallPartResult = Extract<AgentMessagePart, { type: "tool-call" }>
-
 // ── toUiMessage (read) ────────────────────────────────────────────────────────────────────────
 
 /** Reconstruct an SDK-shaped UI message from a stored message. Exact inverse of {@link fromAiSdk}. */
@@ -410,7 +422,7 @@ function toUiPart(part: AgentMessagePart): AgentUiMessagePart {
   }
 }
 
-function toUiToolPart(part: AgentToolCallPartResult): AgentUiToolPart {
+function toUiToolPart(part: AgentToolCallPart): AgentUiToolPart {
   const body = {
     toolCallId: part.toolCallId,
     ...(part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted }),
@@ -570,17 +582,17 @@ function appendAssistantModelMessages<TMessage extends AgentMessage>(
       } else if (part.type === "tool-call") {
         content.push(toolCallModelPart(part))
         if (part.providerExecuted === true) {
-          content.push(toolResultModelPart(part, "json"))
+          content.push(toolResultModelPart(message, part, partIndex, "json", options))
         }
       }
     }
     result.push({ role: "assistant", content })
 
-    const toolResults = current
-      .map(({ part }) => part)
-      .filter(isToolCallPart)
-      .filter((part) => part.providerExecuted !== true)
-      .map((part) => toolResultModelPart(part, "text"))
+    const toolResults = current.flatMap(({ part, partIndex }) =>
+      part.type === "tool-call" && part.providerExecuted !== true
+        ? [toolResultModelPart(message, part, partIndex, "text", options)]
+        : []
+    )
     if (toolResults.length > 0) {
       result.push({ role: "tool", content: toolResults })
     }
@@ -596,7 +608,7 @@ function appendAssistantModelMessages<TMessage extends AgentMessage>(
   flush()
 }
 
-function toolCallModelPart(part: AgentToolCallPartResult): AgentModelToolCallPart {
+function toolCallModelPart(part: AgentToolCallPart): AgentModelToolCallPart {
   return {
     type: "tool-call",
     toolCallId: part.toolCallId,
@@ -607,37 +619,66 @@ function toolCallModelPart(part: AgentToolCallPartResult): AgentModelToolCallPar
   }
 }
 
-function toolResultModelPart(
-  part: AgentToolCallPartResult,
-  errorMode: "text" | "json"
+function toolResultModelPart<TMessage extends AgentMessage>(
+  message: TMessage,
+  part: AgentToolCallPart,
+  partIndex: number,
+  errorMode: "text" | "json",
+  options: ToModelMessagesOptions<TMessage>
 ): AgentModelToolResultPart {
   return {
     type: "tool-result",
     toolCallId: part.toolCallId,
     toolName: part.toolName,
-    output: toolResultOutput(part, errorMode),
+    output: toolResultOutput(message, part, partIndex, errorMode, options),
     ...(part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }),
   }
 }
 
-function toolResultOutput(
-  part: AgentToolCallPartResult,
-  errorMode: "text" | "json"
+function toolResultOutput<TMessage extends AgentMessage>(
+  message: TMessage,
+  part: AgentToolCallPart,
+  partIndex: number,
+  errorMode: "text" | "json",
+  options: ToModelMessagesOptions<TMessage>
 ): AgentModelToolOutput {
   if (part.state === "output-error") {
     return errorMode === "json"
       ? { type: "error-json", value: part.errorText }
       : { type: "error-text", value: part.errorText }
   }
+  if (isAgentToolResult(part.output)) {
+    const value: string[] = []
+    part.output.content.forEach((contentPart, contentIndex) => {
+      if (contentPart.type === "text") {
+        value.push(contentPart.text)
+        return
+      }
+
+      const resolverInput = { message, part, partIndex, contentPart, contentIndex }
+      const fileContext = options.toolResultFileText?.(resolverInput)
+      if (fileContext) {
+        value.push(fileContext)
+      } else {
+        value.push(toolResultFileFallbackText(contentPart))
+      }
+    })
+    return { type: "text", value: value.join("\n") }
+  }
   return typeof part.output === "string"
     ? { type: "text", value: part.output }
     : { type: "json", value: part.output }
 }
 
-function isTextPart(part: AgentMessagePart): part is Extract<AgentMessagePart, { type: "text" }> {
-  return part.type === "text"
+function toolResultFileFallbackText(part: AgentToolFileContent): string {
+  const attributes = [
+    part.fileRef.fileName ? `name=${JSON.stringify(part.fileRef.fileName)}` : undefined,
+    part.fileRef.mediaType ? `mediaType=${JSON.stringify(part.fileRef.mediaType)}` : undefined,
+    `sizeBytes=${part.fileRef.sizeBytes}`,
+  ].filter((value): value is string => value !== undefined)
+  return `[Tool-created file: ${attributes.join(" ")}. Contents are not available inline.]`
 }
 
-function isToolCallPart(part: AgentMessagePart): part is AgentToolCallPartResult {
-  return part.type === "tool-call"
+function isTextPart(part: AgentMessagePart): part is Extract<AgentMessagePart, { type: "text" }> {
+  return part.type === "text"
 }

package/src/agents/builders.ts

@@ -16,10 +16,10 @@ import {
   assertValidAgentToolDescription,
   assertValidAgentToolInput,
   assertValidAgentToolName,
-  assertValidLoopConfig,
   assertValidProviderOptions,
   assertValidReasoningLevel,
   groupIdsFromDefinitions,
+  resolveAgentLoopConfig,
 } from "./validation"
 
 /**
@@ -76,7 +76,7 @@ export function defineAgent<const TId extends string>(
   }
   assertValidReasoningLevel(config.reasoning)
   assertValidProviderOptions(config.providerOptions)
-  assertValidLoopConfig(config.loop)
+  const loop = resolveAgentLoopConfig(config.loop)
   const groupIds = groupIdsFromDefinitions(id, config.groups)
   const tools = toolsFromDefinitions(id, config.tools)
 
@@ -91,6 +91,6 @@ export function defineAgent<const TId extends string>(
     groupIds,
     tools,
     ...(config.description !== undefined ? { description: config.description } : {}),
-    ...(config.loop !== undefined ? { loop: config.loop } : {}),
+    ...(loop !== undefined ? { loop } : {}),
   })
 }

package/src/agents/context-compaction.ts

@@ -0,0 +1,261 @@
+import { stableJsonStringify } from "../json"
+import type { AgentMessageRecord } from "../storage/agents/types"
+import type { AgentMessage, AgentMessagePart } from "./message"
+
+export const AGENT_CONTEXT_ESTIMATOR_VERSION = 1 as const
+
+const CHARS_PER_TOKEN = 4
+const REQUEST_OVERHEAD_TOKENS = 8
+const MESSAGE_OVERHEAD_TOKENS = 8
+const TOOL_OVERHEAD_TOKENS = 16
+const STEP_OVERHEAD_TOKENS = 2
+const IMAGE_ALLOWANCE_TOKENS = 1_200
+const FILE_TEXT_INLINE_MAX_BYTES = 50 * 1024
+const FILE_TEXT_INLINE_TOTAL_MAX_BYTES = 200 * 1024
+const TOOL_RESULT_SUMMARY_MAX_CHARS = 2_000
+
+export interface AgentContextEstimateTool {
+  readonly name: string
+  readonly description: string
+  /** Deterministic JSON-schema serialization sent for this tool. */
+  readonly inputSchema: string
+}
+
+export interface EstimateAgentContextRequestTokensInput {
+  readonly systemPrompt: string
+  readonly tools: readonly AgentContextEstimateTool[]
+  readonly messages: readonly AgentMessage[]
+}
+
+export interface AgentContextTokenEstimate {
+  readonly tokens: number
+  readonly estimatorVersion: typeof AGENT_CONTEXT_ESTIMATOR_VERSION
+}
+
+export interface AgentContextCompactionBoundary {
+  readonly messagesToSummarize: readonly AgentMessageRecord[]
+  readonly retainedMessages: readonly AgentMessageRecord[]
+  readonly summarizedThroughSeq: number
+}
+
+/** Compaction begins only once the estimated request crosses the reserved input budget. */
+export function shouldCompactAgentContext(input: {
+  readonly estimatedInputTokens: number
+  readonly inputBudgetTokens: number
+}): boolean {
+  return input.estimatedInputTokens > input.inputBudgetTokens
+}
+
+/** Estimate the provider request shape with one stable, conservative character heuristic. */
+export function estimateAgentContextRequestTokens(
+  input: EstimateAgentContextRequestTokensInput
+): AgentContextTokenEstimate {
+  const toolTokens = input.tools.reduce(
+    (total, tool) =>
+      total +
+      TOOL_OVERHEAD_TOKENS +
+      textTokens(tool.name) +
+      textTokens(tool.description) +
+      textTokens(tool.inputSchema),
+    0
+  )
+  return {
+    tokens:
+      REQUEST_OVERHEAD_TOKENS +
+      textTokens(input.systemPrompt) +
+      toolTokens +
+      estimateAgentContextMessagesTokens(input.messages).tokens,
+    estimatorVersion: AGENT_CONTEXT_ESTIMATOR_VERSION,
+  }
+}
+
+/** Estimate message-only growth after a provider-usage anchor. */
+export function estimateAgentContextMessagesTokens(
+  messages: readonly AgentMessage[]
+): AgentContextTokenEstimate {
+  const attachments = { textBytesRemaining: FILE_TEXT_INLINE_TOTAL_MAX_BYTES }
+  let tokens = 0
+  for (const message of messages) {
+    tokens += estimateMessageTokens(message, attachments)
+  }
+  return { tokens, estimatorVersion: AGENT_CONTEXT_ESTIMATOR_VERSION }
+}
+
+/** Select the safe user boundary whose retained tail is closest to the configured recent budget. */
+export function selectAgentContextCompactionBoundary(input: {
+  readonly messages: readonly AgentMessageRecord[]
+  readonly keepRecentTokens: number
+}): AgentContextCompactionBoundary | null {
+  if (input.messages.length < 2) return null
+
+  let retainedTokens = 0
+  let boundaryIndex: number | null = null
+  let closestDistance = Number.POSITIVE_INFINITY
+  for (let index = input.messages.length - 1; index > 0; index -= 1) {
+    retainedTokens += estimateAgentContextMessagesTokens([input.messages[index]!]).tokens
+    if (input.messages[index]?.role !== "user") continue
+
+    const distance = Math.abs(input.keepRecentTokens - retainedTokens)
+    if (distance <= closestDistance) {
+      boundaryIndex = index
+      closestDistance = distance
+    }
+    if (retainedTokens >= input.keepRecentTokens) break
+  }
+
+  if (boundaryIndex === null) return null
+
+  const summarizedThroughSeq = input.messages[boundaryIndex - 1]?.seq
+  if (summarizedThroughSeq === undefined) return null
+  return {
+    messagesToSummarize: input.messages.slice(0, boundaryIndex),
+    retainedMessages: input.messages.slice(boundaryIndex),
+    summarizedThroughSeq,
+  }
+}
+
+/** Serialize durable conversation content as escaped quoted data for the summary model. */
+export function serializeAgentMessagesForSummary(messages: readonly AgentMessageRecord[]): string {
+  const lines = ["<sixb_conversation_history>"]
+  for (const message of messages) {
+    lines.push(
+      `  <message id="${escapeXml(message.id)}" seq="${message.seq}" role="${message.role}">`
+    )
+    message.parts.forEach((part, partIndex) => {
+      lines.push(...serializeSummaryPart(message, part, partIndex))
+    })
+    lines.push("  </message>")
+  }
+  lines.push("</sixb_conversation_history>")
+  return lines.join("\n")
+}
+
+function estimateMessageTokens(
+  message: AgentMessage,
+  attachments: { textBytesRemaining: number }
+): number {
+  let tokens = MESSAGE_OVERHEAD_TOKENS
+  for (const part of message.parts) {
+    switch (part.type) {
+      case "text":
+      case "reasoning":
+        tokens += textTokens(part.text)
+        break
+      case "step-start":
+        tokens += STEP_OVERHEAD_TOKENS
+        break
+      case "context":
+        tokens += textTokens(stableJsonStringify(part.context))
+        break
+      case "tool-call":
+        tokens +=
+          TOOL_OVERHEAD_TOKENS +
+          textTokens(part.toolName) +
+          textTokens(stableJsonStringify(part.input)) +
+          (part.state === "output-available"
+            ? textTokens(stableJsonStringify(part.output))
+            : textTokens(part.errorText))
+        break
+      case "file": {
+        const file = part.fileRef
+        tokens += textTokens(
+          [file.blobId, file.digest, file.fileName, file.mediaType, file.logicalPath]
+            .filter((value): value is string => value !== undefined)
+            .join(" ")
+        )
+        if (message.role !== "assistant") {
+          if (looksLikeImage(file.mediaType, file.fileName)) {
+            tokens += IMAGE_ALLOWANCE_TOKENS
+          } else {
+            const inlineBytes = Math.min(
+              file.sizeBytes,
+              FILE_TEXT_INLINE_MAX_BYTES,
+              attachments.textBytesRemaining
+            )
+            attachments.textBytesRemaining -= inlineBytes
+            tokens += Math.ceil(inlineBytes / CHARS_PER_TOKEN)
+          }
+        }
+        break
+      }
+    }
+  }
+  return tokens
+}
+
+function serializeSummaryPart(
+  message: AgentMessageRecord,
+  part: AgentMessagePart,
+  partIndex: number
+): string[] {
+  const indent = "    "
+  switch (part.type) {
+    case "text":
+      return [`${indent}<text>${escapeXml(part.text)}</text>`]
+    case "reasoning":
+    case "step-start":
+      return []
+    case "context":
+      return part.context.kind === "object"
+        ? [
+            `${indent}<object_context origin="${part.origin}" object_type_id="${escapeXml(part.context.ref.objectTypeId)}" primary_id="${escapeXml(part.context.ref.primaryId)}" />`,
+          ]
+        : [
+            `${indent}<app_context origin="${part.origin}" id="${escapeXml(part.context.id)}" label="${escapeXml(part.context.label)}">`,
+            `${indent}  <description>${escapeXml(part.context.description)}</description>`,
+            `${indent}  <value format="json">${escapeXml(stableJsonStringify(part.context.value))}</value>`,
+            `${indent}</app_context>`,
+          ]
+    case "file": {
+      const file = part.fileRef
+      const attributes = [
+        `message_id="${escapeXml(message.id)}"`,
+        `part_index="${partIndex}"`,
+        `blob_id="${escapeXml(file.blobId)}"`,
+        `digest="${escapeXml(file.digest)}"`,
+        `size_bytes="${file.sizeBytes}"`,
+        ...(file.fileName === undefined ? [] : [`file_name="${escapeXml(file.fileName)}"`]),
+        ...(file.mediaType === undefined ? [] : [`media_type="${escapeXml(file.mediaType)}"`]),
+        ...(file.logicalPath === undefined
+          ? []
+          : [`logical_path="${escapeXml(file.logicalPath)}"`]),
+      ]
+      return [`${indent}<file ${attributes.join(" ")} />`]
+    }
+    case "tool-call": {
+      const output =
+        part.state === "output-available"
+          ? truncateToolResult(stableJsonStringify(part.output))
+          : truncateToolResult(part.errorText)
+      return [
+        `${indent}<tool_call id="${escapeXml(part.toolCallId)}" name="${escapeXml(part.toolName)}" state="${part.state}">`,
+        `${indent}  <input format="json">${escapeXml(stableJsonStringify(part.input))}</input>`,
+        `${indent}  <result>${escapeXml(output)}</result>`,
+        `${indent}</tool_call>`,
+      ]
+    }
+  }
+}
+
+function truncateToolResult(value: string): string {
+  if (value.length <= TOOL_RESULT_SUMMARY_MAX_CHARS) return value
+  return `${value.slice(0, TOOL_RESULT_SUMMARY_MAX_CHARS)}\n[truncated ${value.length - TOOL_RESULT_SUMMARY_MAX_CHARS} characters]`
+}
+
+function looksLikeImage(mediaType: string | undefined, fileName: string | undefined): boolean {
+  if (mediaType?.toLowerCase().startsWith("image/")) return true
+  return /\.(?:avif|gif|jpe?g|png|webp)$/i.test(fileName ?? "")
+}
+
+function textTokens(value: string): number {
+  return Math.ceil(new TextEncoder().encode(value).byteLength / CHARS_PER_TOKEN)
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;")
+}

package/src/agents/errors.ts

@@ -25,7 +25,7 @@ export class AgentToolPublicError extends Error {
   readonly name: string = "AgentToolPublicError"
 }
 
-/** Raised when an agent tool result cannot cross the durable JSON message boundary. */
+/** Raised when an agent tool result cannot cross the durable message boundary. */
 export class AgentToolResultValidationError extends Error {
   readonly name = "AgentToolResultValidationError"
 
@@ -34,7 +34,7 @@ export class AgentToolResultValidationError extends Error {
     readonly reason: string,
     options?: ErrorOptions
   ) {
-    super(`[Sixb] Agent tool '${toolName}' result must be a JSON value; ${reason}.`, options)
+    super(`[Sixb] Agent tool '${toolName}' returned an invalid result; ${reason}.`, options)
   }
 }
 

package/src/agents/execution.ts

@@ -1,6 +1,7 @@
 import { principalsEqual, SYSTEM_PRINCIPAL } from "../auth"
 import { assertAuthorized, isAllowed } from "../authorization"
 import type { AuthorizablePrincipal, ExecutionContext } from "../execution"
+import { resolveExecutionCosts } from "../runtime/ai-cost"
 import { resolveExecutionUsage } from "../runtime/ai-usage"
 import type { SixbRuntimeContext } from "../runtime/types"
 import type { SecurityDefinitionCatalog } from "../security"
@@ -12,6 +13,7 @@ import type {
   ListAgentThreadsInput,
   ListAgentThreadsResult,
 } from "../storage/agents"
+import type { AiCostSummary } from "../storage/ai-cost"
 import type { AiModelCallUsage } from "../storage/ai-usage"
 import { AgentRequestError } from "./errors"
 import { createAgentThreadId } from "./ids"
@@ -56,6 +58,8 @@ export interface AgentRunView extends AgentRunRecord {
   readonly requestedBy?: AuthorizablePrincipal
   /** Derived from the model-call ledger; never persisted on the Agent run row. */
   readonly usage?: AiModelCallUsage
+  /** Preferred valuation; omitted when there are no calls or cost storage is unavailable. */
+  readonly cost?: AiCostSummary
 }
 
 export interface AgentRunListResult extends Omit<ListAgentRunsResult, "runs"> {
@@ -219,7 +223,8 @@ async function attachRunViews(
   runtime: SixbRuntimeContext,
   runs: readonly AgentRunRecord[]
 ): Promise<readonly AgentRunView[]> {
-  const [executions, usages] = await Promise.all([
+  const executionIds = runs.map((run) => run.executionId)
+  const [executions, usages, costs] = await Promise.all([
     Promise.all(
       runs.map((run) =>
         runtime.storage.executions.getById({
@@ -231,7 +236,12 @@ async function attachRunViews(
     resolveExecutionUsage({
       storage: runtime.storage.aiUsage,
       projectId: runtime.projectId,
-      executionIds: runs.map((run) => run.executionId),
+      executionIds,
+    }),
+    resolveExecutionCosts({
+      storage: runtime.storage.aiCosts,
+      projectId: runtime.projectId,
+      executionIds,
     }),
   ])
 
@@ -243,12 +253,14 @@ async function attachRunViews(
       )
     }
     const usage = usages[index]
+    const cost = usage === undefined ? undefined : costs[index]
     return {
       ...run,
       ...(execution.requestedBy === undefined
         ? {}
         : { requestedBy: structuredClone(execution.requestedBy) }),
       ...(usage === undefined ? {} : { usage }),
+      ...(cost === undefined ? {} : { cost }),
     }
   })
 }

package/src/agents/ids.ts

@@ -18,6 +18,11 @@ export function createAgentMessageId(): string {
   return `agt_msg_${randomUUID()}`
 }
 
+/** One deterministic context-checkpoint identity per conversational run. */
+export function agentContextCheckpointId(runId: string): string {
+  return `agt_ctx_${runId}`
+}
+
 /** A queue delivery's fencing token for writes to an `agent_runs` record. */
 export function createAgentRunExecutionToken(): string {
   return `agt_exec_${randomUUID()}`

package/src/agents/index.ts

@@ -11,6 +11,7 @@ export type {
   AgentModelToolCallPart,
   AgentModelToolOutput,
   AgentModelToolResultPart,
+  AgentToolResultFileResolverInput,
   AgentUiMessage,
   AgentUiMessagePart,
   AgentUiToolPart,
@@ -52,6 +53,20 @@ export {
   MAX_AGENT_CONTEXT_ENTRIES,
   normalizeAgentContextEntries,
 } from "./context"
+export type {
+  AgentContextCompactionBoundary,
+  AgentContextEstimateTool,
+  AgentContextTokenEstimate,
+  EstimateAgentContextRequestTokensInput,
+} from "./context-compaction"
+export {
+  AGENT_CONTEXT_ESTIMATOR_VERSION,
+  estimateAgentContextMessagesTokens,
+  estimateAgentContextRequestTokens,
+  selectAgentContextCompactionBoundary,
+  serializeAgentMessagesForSummary,
+  shouldCompactAgentContext,
+} from "./context-compaction"
 export { serializeAgentContextForModel } from "./context-model"
 export { resolveAgentContextParts } from "./context-resolution"
 export type {
@@ -74,6 +89,7 @@ export {
   AgentToolResultValidationError,
 } from "./errors"
 export {
+  agentContextCheckpointId,
   createAgentMessageId,
   createAgentRunExecutionToken,
   createAgentRunId,
@@ -92,12 +108,6 @@ export {
   type AgentToolCallPart,
   type AgentToolCallState,
 } from "./message"
-export {
-  type BuildAgentSystemPromptInput,
-  buildAgentSystemPrompt,
-  DEFAULT_AGENT_SYSTEM_CONTEXT,
-  DEFAULT_AGENT_TASK_SYSTEM_CONTEXT,
-} from "./prompt"
 export {
   type RequestAgentRunInput,
   type RequestAgentRunResult,
@@ -105,6 +115,7 @@ export {
   retryAgentRun,
 } from "./request"
 export type {
+  AgentCompactionFailureCode,
   AgentRunControlStreamId,
   AgentRunFailure,
   AgentRunFinishedEvent,
@@ -112,6 +123,7 @@ export type {
   AgentRunStreamId,
 } from "./streams"
 export {
+  AGENT_COMPACTION_FAILURE_CODES,
   AGENT_RUN_CANCEL_RECORD,
   AGENT_RUN_STREAM_SCHEMA_VERSION,
   agentRunControlStreamDefinition,
@@ -127,18 +139,32 @@ export {
   subscribeAgentRunCancel,
 } from "./streams"
 export type {
+  AgentThreadModelContextMessage,
+  ProjectAgentThreadModelContextInput,
+} from "./thread-context-projection"
+export { projectAgentThreadModelContext } from "./thread-context-projection"
+export { isAgentToolResult } from "./tool-result"
+export type {
+  AgentContextConfig,
   AgentDefinition,
   AgentLoopConfig,
   AgentReasoningLevel,
+  AgentToolArtifact,
+  AgentToolArtifactPutInput,
+  AgentToolArtifacts,
+  AgentToolContent,
   AgentToolDefinition,
   AgentToolDescriptionBuilder,
+  AgentToolFileContent,
   AgentToolHandler,
   AgentToolHandlerResult,
   AgentToolInputBuilder,
   AgentToolInputSchema,
+  AgentToolResult,
   AgentToolRunBuilder,
   AgentToolRunContext,
   AgentToolRunInfo,
+  AgentToolTextContent,
   DefineAgentConfig,
   InferAgentToolInput,
   InferAgentToolInputSchema,

package/src/agents/request.ts

@@ -205,6 +205,11 @@ export async function retryAgentRun(
     if (!agents) {
       throw new AgentRequestError("storage_unavailable", "[Sixb] Agent storage is not configured.")
     }
+    await agents.messages.deleteByRunId({
+      projectId: runtime.projectId,
+      threadId: failedRun.threadId,
+      runId: failedRun.id,
+    })
     await tx.executions.create(durableExecution)
     return agents.runs.create({
       id: runId,