@sixb/core 0.1.6 → 0.1.7

package/src/agents/execution.ts

@@ -1,13 +1,13 @@
 import { principalsEqual, SYSTEM_PRINCIPAL } from "../auth"
 import { assertAuthorized, isAllowed } from "../authorization"
 import type { AuthorizablePrincipal, ExecutionContext } from "../execution"
+import type { ModelCatalog } from "../models"
 import { resolveExecutionCosts } from "../runtime/ai-cost"
 import { resolveExecutionUsage } from "../runtime/ai-usage"
 import type { SixbRuntimeContext } from "../runtime/types"
-import type { SecurityDefinitionCatalog } from "../security"
 import type {
-  AgentRunRecord,
   AgentThreadRecord,
+  ConversationAgentRunRecord,
   ListAgentRunsInput,
   ListAgentRunsResult,
   ListAgentThreadsInput,
@@ -23,17 +23,17 @@ import {
   requestAgentRun,
   retryAgentRun,
 } from "./request"
-import type { AgentDefinition } from "./types"
+import { assertNoAgentSelector } from "./retired-config"
+import type { AgentDescriptor } from "./types"
 
 export type ExecutionAgentRequestInput = Omit<RequestAgentRunInput, "principal">
 export type ListExecutionAgentThreadsInput = Omit<
   ListAgentThreadsInput,
-  "projectId" | "agentIds" | "ownerPrincipal"
+  "projectId" | "ownerPrincipal"
 >
 
 export interface CreateExecutionAgentThreadInput {
   readonly id?: string
-  readonly agentId: string
   readonly title?: string
 }
 
@@ -54,7 +54,7 @@ export interface AgentRunsRuntime {
 }
 
 /** Execution-facing run view with provenance resolved from the immutable execution ledger. */
-export interface AgentRunView extends AgentRunRecord {
+export interface AgentRunView extends ConversationAgentRunRecord {
   readonly requestedBy?: AuthorizablePrincipal
   /** Derived from the model-call ledger; never persisted on the Agent run row. */
   readonly usage?: AiModelCallUsage
@@ -70,49 +70,51 @@ export interface ExecutionAgentRunResult extends Omit<RequestAgentRunResult, "ru
   readonly run: AgentRunView
 }
 
-export interface AgentsRuntime {
-  list(): readonly AgentDefinition[]
-  getById(agentId: string): AgentDefinition | null
+export interface AgentRuntime {
+  /** Null when no language models are configured or the caller cannot run the Agent. */
+  get(): AgentDescriptor | null
   readonly threads: AgentThreadsRuntime
   readonly runs: AgentRunsRuntime
 }
 
-export function createAgentsRuntime(
+export function createAgentRuntime(
   runtime: SixbRuntimeContext,
   execution: ExecutionContext,
-  source: Pick<AgentsRuntime, "list" | "getById">,
-  security: SecurityDefinitionCatalog
-): AgentsRuntime {
+  models?: ModelCatalog
+): AgentRuntime {
   const principal = runtime.authorization?.principal ?? SYSTEM_PRINCIPAL
-  const allowed = (agentId: string) =>
-    isAllowed(runtime.authorization, { kind: "agent.run", agentId })
+  const allowed = () => isAllowed(runtime.authorization, { kind: "agent.run" })
 
-  const getThread = async (threadId: string) => {
+  const getVisibleThreadRecord = async (threadId: string): Promise<AgentThreadRecord | null> => {
     const thread =
       (await runtime.storage.agents?.threads.getById({
         projectId: runtime.projectId,
         id: threadId,
       })) ?? null
-    if (!thread || !allowed(thread.agentId)) return null
+    if (!thread || !allowed()) return null
     return runtime.authorization && !principalsEqual(principal, thread.ownerPrincipal)
       ? null
       : thread
   }
 
-  const getAgent = (agentId: string) => {
-    const agent = source.getById(agentId)
-    return agent && allowed(agentId) ? agent : null
+  const getAgent = (): AgentDescriptor | null => {
+    const model = models?.language.default
+    if (!model || !allowed()) return null
+    return {
+      name: "Sixb",
+      model: { provider: model.provider, modelId: model.modelId },
+    }
   }
 
-  const getVisibleRunRecord = async (runId: string): Promise<AgentRunRecord | null> => {
+  const getVisibleRunRecord = async (runId: string): Promise<ConversationAgentRunRecord | null> => {
     const run =
       (await runtime.storage.agents?.runs.getById({
         projectId: runtime.projectId,
         id: runId,
       })) ?? null
-    if (!run) return null
-    const thread = await getThread(run.threadId)
-    return thread?.agentId === run.agentId ? run : null
+    if (!run || run.kind !== "conversation") return null
+    const thread = await getVisibleThreadRecord(run.threadId)
+    return thread ? run : null
   }
 
   const getRun = async (runId: string): Promise<AgentRunView | null> => {
@@ -121,13 +123,13 @@ export function createAgentsRuntime(
   }
 
   return {
-    list: () => source.list().filter((agent) => allowed(agent.id)),
-    getById: getAgent,
+    get: getAgent,
     threads: {
       create: async (input) => {
-        const agent = getAgent(input.agentId)
+        assertNoAgentSelector(input)
+        const agent = getAgent()
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", `[Sixb] Unknown agent '${input.agentId}'.`)
+          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.")
         }
         const storage = runtime.storage.agents
         if (!storage) {
@@ -139,39 +141,37 @@ export function createAgentsRuntime(
         return storage.threads.create({
           id: input.id ?? createAgentThreadId(),
           projectId: runtime.projectId,
-          agentId: agent.id,
           ownerPrincipal: principal,
           ...(input.title === undefined ? {} : { title: input.title }),
         })
       },
-      getById: getThread,
-      list: (input = {}) => {
+      getById: getVisibleThreadRecord,
+      list: async (input = {}) => {
+        assertNoAgentSelector(input)
         const storage = runtime.storage.agents
-        if (!storage) return Promise.resolve({ threads: [], hasMore: false, total: 0 })
+        if (!storage || !allowed()) return { threads: [], hasMore: false, total: 0 }
         return storage.threads.list({
-          projectId: runtime.projectId,
           ...input,
-          agentIds: runtime.authorization
-            ? [...runtime.authorization.grants["run:agent"]]
-            : undefined,
+          projectId: runtime.projectId,
           ownerPrincipal: runtime.authorization ? principal : undefined,
         })
       },
     },
     runs: {
       request: async (input) => {
-        const agent = source.getById(input.agentId)
+        assertNoAgentSelector(input)
+        const agent = getAgent()
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", `[Sixb] Unknown agent '${input.agentId}'.`)
+          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.")
         }
-        assertAuthorized(runtime, { kind: "agent.run", agentId: agent.id })
-        if (input.threadId && !(await getThread(input.threadId))) {
+        assertAuthorized(runtime, { kind: "agent.run" })
+        if (input.threadId && !(await getVisibleThreadRecord(input.threadId))) {
           throw new AgentRequestError(
             "thread_not_found",
             `[Sixb] Agent thread '${input.threadId}' not found.`
           )
         }
-        const result = await requestAgentRun(runtime, execution, security, agent, {
+        const result = await requestAgentRun(runtime, execution, models?.language, {
           ...input,
           principal,
         })
@@ -182,28 +182,29 @@ export function createAgentsRuntime(
         if (!failedRun) {
           throw new AgentRequestError("run_not_found", `[Sixb] Agent run '${runId}' was not found.`)
         }
-        const agent = getAgent(failedRun.agentId)
+        const agent = getAgent()
         if (!agent) {
-          throw new AgentRequestError(
-            "agent_not_found",
-            `[Sixb] Unknown agent '${failedRun.agentId}'.`
-          )
+          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.")
         }
-        const result = await retryAgentRun(runtime, execution, security, agent, failedRun)
+        const result = await retryAgentRun(runtime, execution, models?.language, failedRun)
         return { ...result, run: await attachRunView(runtime, result.run) }
       },
       getById: getRun,
       listForThread: async (threadId, input = {}) => {
+        assertNoAgentSelector(input)
         const storage = runtime.storage.agents
-        if (!storage || !(await getThread(threadId))) return null
+        if (!storage || !(await getVisibleThreadRecord(threadId))) return null
         const result = await storage.runs.list({
-          projectId: runtime.projectId,
           ...input,
+          projectId: runtime.projectId,
           threadId,
         })
         return {
           ...result,
-          runs: await attachRunViews(runtime, result.runs),
+          runs: await attachRunViews(
+            runtime,
+            result.runs.filter((run) => run.kind === "conversation")
+          ),
         }
       },
     },
@@ -212,7 +213,7 @@ export function createAgentsRuntime(
 
 async function attachRunView(
   runtime: SixbRuntimeContext,
-  run: AgentRunRecord
+  run: ConversationAgentRunRecord
 ): Promise<AgentRunView> {
   const [view] = await attachRunViews(runtime, [run])
   if (!view) throw new Error(`[Sixb] Could not build Agent run '${run.id}' view.`)
@@ -221,7 +222,7 @@ async function attachRunView(
 
 async function attachRunViews(
   runtime: SixbRuntimeContext,
-  runs: readonly AgentRunRecord[]
+  runs: readonly ConversationAgentRunRecord[]
 ): Promise<readonly AgentRunView[]> {
   const executionIds = runs.map((run) => run.executionId)
   const [executions, usages, costs] = await Promise.all([

package/src/agents/ids.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto"
+import { createHash, randomUUID } from "node:crypto"
 
 /**
  * Id helpers for agent persistence. Threads, the run id, and the user (trigger) message are minted
@@ -14,6 +14,21 @@ export function createAgentRunId(): string {
   return `agt_run_${randomUUID()}`
 }
 
+/** One stable child identity per parent-selected spawn key. */
+export function createSubagentRunId(parentRunId: string, spawnKey: string): string {
+  const digest = createHash("sha256")
+    .update(parentRunId)
+    .update("\0")
+    .update(spawnKey)
+    .digest("hex")
+  return `agt_run_child_${digest}`
+}
+
+/** Stable execution identity paired with a deterministic child run. */
+export function createSubagentExecutionId(runId: string): string {
+  return `exec_${runId}`
+}
+
 export function createAgentMessageId(): string {
   return `agt_msg_${randomUUID()}`
 }

package/src/agents/index.ts

@@ -18,7 +18,7 @@ export type {
   ToModelMessagesOptions,
 } from "./adapters"
 export {
-  fromAiSdk,
+  fromUiMessage,
   omitUndefinedObjectProperties,
   toModelMessages,
   toUiMessage,
@@ -31,13 +31,14 @@ export {
   isAllowedAgentApiRequest,
   isValidAgentApiGatewayCapability,
 } from "./api-gateway"
-export type { AgentExecutionIdentity } from "./authority"
+export type { AgentExecutionAuthorization, AgentExecutionIdentity } from "./authority"
 export {
   agentServiceAccountId,
-  ensureAgentExecutionIdentity,
+  ensureManagedAgentExecutionIdentity,
   resolveAgentExecutionAuthorization,
+  resolveInheritedAgentExecutionAuthorization,
 } from "./authority"
-export { defineAgent, defineAgentTool } from "./builders"
+export { defineAgentTool } from "./builders"
 export type {
   AgentContextEntryInput,
   AgentContextInput,
@@ -78,6 +79,8 @@ export type {
 export {
   agentRunQueueJobId,
   dispatchQueuedAgentRuns,
+  dispatchQueuedSubagentRuns,
+  subagentRunQueueJobId,
   workflowAgentNodeQueueJobId,
 } from "./dispatch"
 export {
@@ -94,6 +97,8 @@ export {
   createAgentRunExecutionToken,
   createAgentRunId,
   createAgentThreadId,
+  createSubagentExecutionId,
+  createSubagentRunId,
 } from "./ids"
 export {
   AGENT_MESSAGE_CONTENT_VERSION,
@@ -102,12 +107,21 @@ export {
   type AgentMessagePart,
   type AgentMessagePartType,
   type AgentMessageRole,
+  type AgentProviderStatePart,
   type AgentReasoningPart,
   type AgentStepStartPart,
   type AgentTextPart,
   type AgentToolCallPart,
   type AgentToolCallState,
 } from "./message"
+export type {
+  ModelLoopResult,
+  PrepareModelStepInput,
+  PrepareModelStepResult,
+  RunModelLoopInput,
+} from "./model-loop"
+export { runModelLoop } from "./model-loop"
+export { agent } from "./reference"
 export {
   type RequestAgentRunInput,
   type RequestAgentRunResult,
@@ -143,12 +157,13 @@ export type {
   ProjectAgentThreadModelContextInput,
 } from "./thread-context-projection"
 export { projectAgentThreadModelContext } from "./thread-context-projection"
+export type { AgentToolCatalog } from "./tool-catalog"
 export { isAgentToolResult } from "./tool-result"
 export type {
-  AgentContextConfig,
-  AgentDefinition,
-  AgentLoopConfig,
+  AgentDescriptor,
+  AgentReasoning,
   AgentReasoningLevel,
+  AgentReference,
   AgentToolArtifact,
   AgentToolArtifactPutInput,
   AgentToolArtifacts,
@@ -165,16 +180,13 @@ export type {
   AgentToolRunContext,
   AgentToolRunInfo,
   AgentToolTextContent,
-  DefineAgentConfig,
+  AgentUsageReference,
   InferAgentToolInput,
   InferAgentToolInputSchema,
 } from "./types"
 export { AGENT_REASONING_LEVELS } from "./types"
 export {
   AGENT_RESERVED_TOOL_NAMES,
-  isAgentDefinition,
   isAgentToolDefinition,
-  validateAgentGroupReferences,
-  validateAgentToolsAtStartup,
   validateAndNormalizeAgentToolInput,
 } from "./validation"

package/src/agents/message.ts

@@ -1,5 +1,6 @@
 import type { FileRef } from "../blob-storage"
 import type { JsonValue } from "../json"
+import type { ProviderData } from "../models"
 import type { AgentContextPart } from "./context"
 
 /**
@@ -8,12 +9,12 @@ import type { AgentContextPart } from "./context"
  * self-describing wrapper: the storage row owns the message's identity, and `contentVersion` (a
  * column) versions the parts shape so it can be migrated.
  *
- * The part union is intentionally focused on what V1 agents actually produce (text, reasoning, step
+ * The part union is intentionally focused on what agent runs actually produce (text, reasoning, step
  * boundaries, tool calls). It is extensible: adding a part kind later is non-breaking. The adapter
- * `fromAiSdk` is total — it throws on any part it cannot model rather than dropping it silently,
+ * `fromUiMessage` is total — it throws on any part it cannot model rather than dropping it silently,
  * which both prevents data loss and signals exactly when the union must grow.
  */
-export const AGENT_MESSAGE_CONTENT_VERSION = 1 as const
+export const AGENT_MESSAGE_CONTENT_VERSION = 2 as const
 
 export type AgentMessageRole = "system" | "user" | "assistant"
 
@@ -22,7 +23,7 @@ export interface AgentTextPart {
   readonly type: "text"
   readonly text: string
   /** Provider passthrough (kept because some providers require it on the next turn). */
-  readonly providerMetadata?: JsonValue
+  readonly providerMetadata?: ProviderData
 }
 
 /**
@@ -32,7 +33,7 @@ export interface AgentTextPart {
 export interface AgentReasoningPart {
   readonly type: "reasoning"
   readonly text: string
-  readonly providerMetadata?: JsonValue
+  readonly providerMetadata?: ProviderData
 }
 
 /** A step boundary between assistant loop iterations. */
@@ -45,19 +46,26 @@ export interface AgentFilePart {
   readonly type: "file"
   readonly fileRef: FileRef
   /** Provider passthrough for future model-specific file handling. */
-  readonly providerMetadata?: JsonValue
+  readonly providerMetadata?: ProviderData
 }
 
 interface AgentToolCallBase {
   readonly type: "tool-call"
   readonly toolCallId: string
   readonly toolName: string
-  /** `true` when reconstructed from an SDK `dynamic-tool` part (vs a static `tool-${name}` part). */
+  /** `true` when reconstructed from a dynamic tool part (vs a static `tool-${name}` part). */
   readonly dynamic?: boolean
-  /** `true` when the provider executed the tool inline (steers model projection). V1 = `false`. */
+  /** `true` when the provider executed the tool inline (steers model projection). */
   readonly providerExecuted?: boolean
   readonly input: JsonValue
-  readonly providerMetadata?: JsonValue
+  readonly providerMetadata?: ProviderData
+}
+
+/** Ordered, hidden provider state required to replay a model response losslessly. */
+export interface AgentProviderStatePart {
+  readonly type: "provider-state"
+  readonly providerId: string
+  readonly data: JsonValue
 }
 
 /**
@@ -78,6 +86,7 @@ export type AgentMessagePart =
   | AgentFilePart
   | AgentContextPart
   | AgentToolCallPart
+  | AgentProviderStatePart
 
 export type AgentMessagePartType = AgentMessagePart["type"]
 export type AgentToolCallState = AgentToolCallPart["state"]