@sixb/core 0.1.8 → 0.1.9

package/src/actions/types/context.ts

@@ -7,6 +7,7 @@ import type {
   EffectiveObjectChange,
   OntologyOperationOutcome,
 } from "../../materializer"
+import type { ModelsRuntime } from "../../models/generation-types"
 import type { ObjectType, Property, ValueType } from "../../ontology"
 import type { InferPropertyUnit, InferPropertyValue } from "../../ontology/inference"
 import type { LinkToken, ObjectTypeWithPropertyTokens, PropertyToken } from "../../ontology/tokens"
@@ -196,6 +197,7 @@ export interface ActionRuntimeFacade<
   TValueTypes extends readonly ValueType[] = readonly ValueType[],
 > {
   readonly blobs: ActionBlobContext
+  readonly models: ModelsRuntime
   readonly connector: ConnectorRuntime
   objects<const TObjectType extends ObjectTypeWithPropertyTokens>(
     objectType: TObjectType

package/src/actions/validation.ts

@@ -1,6 +1,7 @@
 import type { JsonValue } from "../json"
-import { type SchemaOrRef, type ValueType, validateSchemaOrRefValue } from "../ontology"
+import type { SchemaOrRef, ValueType } from "../ontology"
 import { OntologyValidationError } from "../ontology/errors"
+import { validateSchemaOrRefValue } from "../ontology/refs"
 import type { ObjectTypeWithPropertyTokens } from "../ontology/tokens"
 import type { Schema } from "../ontology/types"
 import { coerceSchemaValueToTyped, normalizeSchemaValue } from "../ontology/validation"

package/src/agents/adapters.ts

@@ -49,7 +49,7 @@ export interface ToModelMessagesOptions<TMessage extends AgentMessage = AgentMes
     | ((input: AgentFileDataResolverInput<TMessage>) => URL | AgentFileDataProjection | undefined)
     | undefined
   /**
-   * Convert a stored file reference into model-readable text context. This is appended before any
+   * Convert a user file reference into model-readable text context. This is appended before any
    * file data part so metadata, truncation notes, and sandbox/API access hints stay visible even for
    * models that cannot consume inline files.
    */
@@ -62,11 +62,11 @@ export interface ToModelMessagesOptions<TMessage extends AgentMessage = AgentMes
 
 /**
  * Project durable messages into Sixb model messages. Assistant parts are grouped
- * into blocks at each `step-start`; each block yields one `assistant` message plus, for any
+ * into blocks at each `step-start`; each nonempty block yields one `assistant` message plus, for any
  * non-provider-executed tool calls, one `tool` message. Provider-executed tool results stay inline
  * in the assistant message. Without a tool registry, a string output maps to `text` and anything
  * else to `json`; this is the documented fidelity scope (a tool's custom `toModelOutput` is not
- * reproduced).
+ * reproduced). Assistant file attachments are not projected as assistant-authored text.
  */
 export function toModelMessages<TMessage extends AgentMessage>(
   messages: readonly TMessage[],
@@ -177,11 +177,6 @@ function appendAssistantModelMessages<TMessage extends AgentMessage>(
           text: part.text,
           ...(part.providerMetadata === undefined ? {} : { providerData: part.providerMetadata }),
         })
-      } else if (part.type === "file") {
-        const fileContext = options.fileText?.({ message, part, partIndex })
-        if (fileContext) {
-          content.push({ type: "text", text: fileContext })
-        }
       } else if (part.type === "tool-call") {
         content.push(toolCallModelPart(part))
         if (part.providerExecuted === true) {
@@ -197,7 +192,7 @@ function appendAssistantModelMessages<TMessage extends AgentMessage>(
         })
       }
     }
-    result.push({ role: "assistant", content })
+    if (content.length > 0) result.push({ role: "assistant", content })
 
     if (toolResults.length > 0) {
       result.push({ role: "tool", content: toolResults })

package/src/agents/{context.ts → context/entries.ts}

@@ -1,7 +1,7 @@
-import type { JsonValue } from "../json"
-import { cloneJsonValue, getInvalidJsonValueReason, stableJsonStringify } from "../json"
-import type { ObjectRef } from "../ontology/refs"
-import { AgentRequestError } from "./errors"
+import type { JsonValue } from "../../json"
+import { cloneJsonValue, getInvalidJsonValueReason, stableJsonStringify } from "../../json"
+import type { ObjectRef } from "../../ontology/refs"
+import { AgentRequestError } from "../errors"
 
 export type AgentContextInput =
   | { readonly kind: "object"; readonly ref: ObjectRef }

package/src/agents/context/index.ts

@@ -0,0 +1,15 @@
+/** Context authoring and comparison for application clients. */
+export type {
+  AgentContextEntryInput,
+  AgentContextInput,
+  AgentContextOrigin,
+  AgentContextPart,
+} from "./entries"
+export {
+  agentContext,
+  agentContextFingerprint,
+  agentContextIdentity,
+  MAX_AGENT_APP_STATE_ENTRY_BYTES,
+  MAX_AGENT_APP_STATE_TOTAL_BYTES,
+  MAX_AGENT_CONTEXT_ENTRIES,
+} from "./entries"

package/src/agents/context-model.ts

@@ -1,5 +1,5 @@
 import { stableJsonStringify } from "../json"
-import type { AgentContextPart } from "./context"
+import type { AgentContextPart } from "./context/entries"
 
 /** Project persisted context into one deterministic, escaped data block for the model. */
 export function serializeAgentContextForModel(

package/src/agents/context-resolution.ts

@@ -3,7 +3,7 @@ import {
   type AgentContextEntryInput,
   type AgentContextPart,
   normalizeAgentContextEntries,
-} from "./context"
+} from "./context/entries"
 import { AgentRequestError } from "./errors"
 
 /** Resolve the exact context parts that will be persisted with the triggering user message. */

package/src/agents/index.ts

@@ -26,7 +26,7 @@ export type {
   AgentContextInput,
   AgentContextOrigin,
   AgentContextPart,
-} from "./context"
+} from "./context/entries"
 export {
   agentContext,
   agentContextFingerprint,
@@ -35,7 +35,7 @@ export {
   MAX_AGENT_APP_STATE_TOTAL_BYTES,
   MAX_AGENT_CONTEXT_ENTRIES,
   normalizeAgentContextEntries,
-} from "./context"
+} from "./context/entries"
 export type {
   AgentContextCompactionBoundary,
   AgentContextEstimateTool,
@@ -116,7 +116,7 @@ export type {
   AgentRunFinishedEvent,
   AgentRunStreamEvent,
   AgentRunStreamId,
-} from "./streams"
+} from "./streams/protocol"
 export {
   AGENT_COMPACTION_FAILURE_CODES,
   AGENT_RUN_CANCEL_RECORD,
@@ -132,7 +132,7 @@ export {
   publishAgentRunCancel,
   publishAgentRunFinished,
   subscribeAgentRunCancel,
-} from "./streams"
+} from "./streams/protocol"
 export type {
   AgentThreadModelContextMessage,
   ProjectAgentThreadModelContextInput,

package/src/agents/message.ts

@@ -1,7 +1,7 @@
 import type { FileRef } from "../blob-storage"
 import type { JsonValue } from "../json"
 import type { ProviderData } from "../models"
-import type { AgentContextPart } from "./context"
+import type { AgentContextPart } from "./context/entries"
 
 /**
  * The agent's own, SDK-independent message. We store messages and threads — not an SDK transport —

package/src/agents/model-loop.ts

@@ -48,6 +48,8 @@ interface ModelLoopOptions {
   readonly maxOutputTokens?: number
   readonly caching?: "auto" | "off"
   readonly maxSteps: number
+  /** Direct generation cannot execute or synthesize local tool results. */
+  readonly rejectLocalToolCalls?: boolean
   readonly signal: AbortSignal
   /** Reserve the final provider call for a tool-free synthesis response. */
   readonly finalStepInstruction?: string
@@ -253,6 +255,12 @@ export async function runModelLoop(
     }
 
     const localCalls = response.toolCalls.filter((call) => call.part.providerExecuted !== true)
+    if (
+      input.rejectLocalToolCalls &&
+      (localCalls.length > 0 || response.finishReason === "tool-calls")
+    ) {
+      throw new ModelStreamError("[SixbModels] Direct generation cannot continue local tool calls.")
+    }
     if (response.finishReason === "pause" && localCalls.length === 0) {
       const step = modelStep(response, responseId, response.content, cost)
       steps.push(step)

package/src/agents/request.ts

@@ -1,7 +1,6 @@
 import { randomUUID } from "node:crypto"
 import type { Principal } from "../auth"
 import { SYSTEM_PRINCIPAL } from "../auth"
-import { snapshotRequesterGroupIds } from "../auth/attribution"
 import { assertAuthorized } from "../authorization"
 import type { FileRef } from "../blob-storage"
 import {
@@ -28,14 +27,14 @@ import {
   applicableAiLimitPolicyStatuses,
 } from "../storage/ai-limits/enforcement"
 import type { AiLimitPolicyStatus } from "../storage/ai-limits/types"
-import type { CreateExecutionInput } from "../storage/executions"
-import type { AgentContextEntryInput } from "./context"
+import type { ExecutionRecord } from "../storage/executions"
+import type { AgentContextEntryInput } from "./context/entries"
 import { resolveAgentContextParts } from "./context-resolution"
 import { dispatchQueuedAgentRuns } from "./dispatch"
 import { AgentRequestError } from "./errors"
 import { createAgentMessageId, createAgentRunId, createAgentThreadId } from "./ids"
 import { assertNoAgentSelector } from "./retired-config"
-import { publishAgentRunActivity } from "./streams"
+import { publishAgentRunActivity } from "./streams/protocol"
 import { AGENT_REASONING_LEVELS, type AgentReasoningLevel } from "./types"
 
 export interface RequestAgentRunInput {
@@ -106,14 +105,7 @@ export async function requestAgentRun(
       : (input.principal ?? SYSTEM_PRINCIPAL)
   const runId = createAgentRunId()
   const durableExecution = await prepareDurableAgentExecution(runtime, execution, runId)
-  const requesterGroupIds = durableExecution.requestedBy
-    ? await snapshotRequesterGroupIds({
-        auth: runtime.storage.auth,
-        projectId,
-        principal: durableExecution.requestedBy,
-      })
-    : []
-  await assertAiLimitPreflight(runtime, durableExecution, requesterGroupIds)
+  await assertAiLimitPreflight(runtime, durableExecution)
 
   const { thread, createdThread } = await resolveThread(agents, {
     projectId,
@@ -161,7 +153,6 @@ export async function requestAgentRun(
         threadId: thread.id,
         triggerMessageId,
         spec,
-        requesterGroupIds,
       })
     })
   } catch (error) {
@@ -214,14 +205,7 @@ export async function retryAgentRun(
   }
   const runId = createAgentRunId()
   const durableExecution = await prepareDurableAgentExecution(runtime, execution, runId)
-  const requesterGroupIds = durableExecution.requestedBy
-    ? await snapshotRequesterGroupIds({
-        auth: runtime.storage.auth,
-        projectId: runtime.projectId,
-        principal: durableExecution.requestedBy,
-      })
-    : []
-  await assertAiLimitPreflight(runtime, durableExecution, requesterGroupIds)
+  await assertAiLimitPreflight(runtime, durableExecution)
   const run = await runtime.storage.transaction(async (tx) => {
     const agents = tx.agents
     if (!agents) {
@@ -245,7 +229,6 @@ export async function retryAgentRun(
           models,
           input: {},
         }),
-      requesterGroupIds,
     })
   })
   await publishRunActivity(runtime, run)
@@ -255,13 +238,15 @@ export async function retryAgentRun(
 
 async function assertAiLimitPreflight(
   runtime: SixbRuntimeContext,
-  execution: CreateExecutionInput,
-  requesterGroupIds: readonly string[]
+  execution: Pick<ExecutionRecord, "requestedBy" | "requesterGroupIds">
 ): Promise<void> {
   const limits = runtime.storage.aiLimits
   if (!limits) throw aiUsageLimitUnavailableError(["limitStorageUnavailable"])
 
-  const subjects = aiLimitSubjectsFromAttribution(execution.requestedBy, requesterGroupIds)
+  const subjects = aiLimitSubjectsFromAttribution(
+    execution.requestedBy,
+    execution.requesterGroupIds
+  )
   let applicable: readonly AiLimitPolicyStatus[]
   try {
     applicable = applicableAiLimitPolicyStatuses(
@@ -322,7 +307,7 @@ async function prepareDurableAgentExecution(
   runtime: SixbRuntimeContext,
   execution: ExecutionContext,
   runId: string
-): Promise<CreateExecutionInput> {
+): Promise<Omit<ExecutionRecord, "createdAt">> {
   const parent = await ensureExecutionRecord(
     runtime.storage.executions,
     executionRecordInputFromRuntime({

package/src/agents/streams/index.ts

@@ -0,0 +1,18 @@
+/** Browser-safe agent stream reader contract. Producers belong to internal/agents/streams. */
+export type {
+  AgentCompactionFailureCode,
+  AgentRunActivityEvent,
+  AgentRunControlStreamId,
+  AgentRunFailure,
+  AgentRunFinishedEvent,
+  AgentRunStreamEvent,
+  AgentRunStreamId,
+} from "./protocol"
+export {
+  AGENT_ACTIVITY_STREAM_ID,
+  AGENT_ACTIVITY_STREAM_SCHEMA_VERSION,
+  AGENT_COMPACTION_FAILURE_CODES,
+  AGENT_RUN_STREAM_SCHEMA_VERSION,
+  isAgentRunActivityEvent,
+  isAgentRunStreamEvent,
+} from "./protocol"

package/src/agents/streams/internal.ts

@@ -0,0 +1,19 @@
+/** Implementation exports for Sixb packages only. */
+export {
+  AGENT_RUN_CANCEL_RECORD,
+  agentActivityStreamDefinition,
+  agentRunActivityEvent,
+  agentRunControlStreamDefinition,
+  agentRunControlStreamId,
+  agentRunFinishedEvent,
+  agentRunStreamDefinition,
+  agentRunStreamEventBase,
+  agentRunStreamId,
+  agentRunStreamIdempotencyKey,
+  DEFAULT_AGENT_ACTIVITY_STREAM_RETENTION,
+  DEFAULT_AGENT_RUN_STREAM_RETENTION,
+  publishAgentRunActivity,
+  publishAgentRunCancel,
+  publishAgentRunFinished,
+  subscribeAgentRunCancel,
+} from "./protocol"

package/src/agents/{streams.ts → streams/protocol.ts}

@@ -1,14 +1,14 @@
-import type { Broker, BrokerStreamDefinition } from "../broker"
-import { parseSixbFailure } from "../errors/internal"
-import type { SixbFailure } from "../errors/types"
-import { isJsonValue, isPlainRecord, type JsonValue } from "../json"
+import type { Broker, BrokerStreamDefinition } from "../../broker"
+import { parseSixbFailure } from "../../errors/internal"
+import type { SixbFailure } from "../../errors/types"
+import { isJsonValue, isPlainRecord, type JsonValue } from "../../json"
 import {
   AGENT_RUN_FAILURE_CODES,
   type AgentContextCheckpointReason,
   type AgentRunFailureCode,
   type AgentRunRecord,
   type ConversationAgentRunRecord,
-} from "../storage/agents/types"
+} from "../../storage/agents/types"
 
 export const AGENT_RUN_STREAM_SCHEMA_VERSION = 1 as const
 export const DEFAULT_AGENT_RUN_STREAM_RETENTION = {

package/src/agents/types.ts

@@ -11,7 +11,7 @@ export type {
   AgentContextInput,
   AgentContextOrigin,
   AgentContextPart,
-} from "./context"
+} from "./context/entries"
 
 /** Public capability reference used by security grants such as `can.run(agent)`. */
 export interface AgentReference {

package/src/agents/validation.ts

@@ -1,11 +1,7 @@
 import { getInvalidJsonValueReason, isPlainRecord, type JsonValue } from "../json"
-import {
-  normalizeSchemaValue,
-  type ObjectSchema,
-  OntologyValidationError,
-  type ValueType,
-  validateSchemaValue,
-} from "../ontology"
+import { type ObjectSchema, OntologyValidationError, type ValueType } from "../ontology"
+import { normalizeSchemaValue } from "../ontology/validation/normalize"
+import { validateSchemaValue } from "../ontology/validation/schema"
 import { AgentDefinitionError } from "./errors"
 import type { AgentToolDefinition, AgentToolInputSchema } from "./types"
 

package/src/auth/index.ts

@@ -9,7 +9,6 @@ export {
   parseAccessTokenValue,
   SERVICE_ACCOUNT_ACCESS_TOKEN_PREFIX,
 } from "./access-tokens"
-export { normalizeRequesterGroupIds, snapshotRequesterGroupIds } from "./attribution"
 export type { AuthSessionAudience, AuthSessionAudienceOptions } from "./audience"
 export {
   DEFAULT_AUTH_SESSION_AUDIENCE,

package/src/bootstrap/discovery.ts

@@ -6,8 +6,9 @@
  * for the `Sixb` constructor.
  */
 
+import { AsyncLocalStorage } from "node:async_hooks"
 import { readdir } from "node:fs/promises"
-import { join, relative } from "node:path"
+import { join, relative, resolve } from "node:path"
 import { pathToFileURL } from "node:url"
 import { isActionDefinition } from "../actions"
 import { isConnectorDefinition } from "../connectors"
@@ -30,13 +31,7 @@ const moduleExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"])
 export async function discoverOntologySources(
   projectRoot: string
 ): Promise<readonly OntologySource[]> {
-  const ontologyDir = join(projectRoot, "ontology")
-  const modulePaths = await listModuleFiles(ontologyDir)
-  const exportedCandidates = await loadModuleExports({
-    modulePaths,
-    projectRoot,
-    kind: "ontology",
-  })
+  const exportedCandidates = await loadFamilyExports(projectRoot, "ontology", ["ontology"])
 
   const ontologyDocuments: OntologyDocumentInput[] = []
   const objectTypes: ObjectTypeWithPropertyTokens[] = []
@@ -71,7 +66,7 @@ export async function discoverOntologySources(
   return discoveredSources
 }
 
-type DiscoveryModuleKind =
+export type DiscoveryModuleKind =
   | "action"
   | "connector"
   | "dataset"
@@ -87,6 +82,31 @@ type DiscoveryModuleKind =
   | "sync"
   | "workflow"
 
+/** Build-time inventory; paths are relative to the source project root. */
+export interface ProjectModule {
+  readonly path: string
+  readonly kind: DiscoveryModuleKind
+}
+
+/** Literal imports generated by the CLI put discovery and config in the same bundle graph. */
+export interface BundledProjectModule extends ProjectModule {
+  readonly load: () => Promise<Record<string, unknown>>
+}
+
+const bundledProject = new AsyncLocalStorage<{
+  readonly projectRoot: string
+  readonly modules: readonly BundledProjectModule[]
+}>()
+
+/** Scope both config evaluation and deferred config factories without process-global state. */
+export function withProjectModules<T>(
+  projectRoot: string,
+  modules: readonly BundledProjectModule[],
+  run: () => T
+): T {
+  return bundledProject.run({ projectRoot: resolve(projectRoot), modules }, run)
+}
+
 interface DefinitionDiscoveryFamily<TDefinition> {
   readonly directory: readonly string[]
   readonly kind: Exclude<DiscoveryModuleKind, "ontology">
@@ -141,6 +161,19 @@ const definitionDiscoveryRegistry = {
   shares: { directory: ["shares"], kind: "share", isDefinition: isShareDefinition },
 } as const satisfies Record<string, DefinitionDiscoveryFamily<unknown>>
 
+/** Inventory every discovery family without evaluating project code. */
+export async function listProjectModules(projectRoot: string): Promise<readonly ProjectModule[]> {
+  const families = [
+    { kind: "ontology" as const, directory: ["ontology"] },
+    ...Object.values(definitionDiscoveryRegistry),
+  ]
+  return (
+    await Promise.all(
+      families.map(({ kind, directory }) => listFamilyModules(projectRoot, kind, directory))
+    )
+  ).flat()
+}
+
 type DefinitionFromFamily<TFamily> =
   TFamily extends DefinitionDiscoveryFamily<infer TDefinition> ? TDefinition : never
 
@@ -169,34 +202,58 @@ async function discoverDefinitionFamily(
   projectRoot: string,
   family: DefinitionDiscoveryFamily<unknown>
 ): Promise<readonly unknown[]> {
-  const modulePaths = await listModuleFiles(join(projectRoot, ...family.directory))
-  const exportedCandidates = await loadModuleExports({
-    modulePaths,
-    projectRoot,
-    kind: family.kind,
-  })
+  const exportedCandidates = await loadFamilyExports(projectRoot, family.kind, family.directory)
 
   return exportedCandidates.filter(family.isDefinition)
 }
 
 // ── Internal helpers ────────────────────────────────────────
 
-async function loadModuleExports(options: {
-  modulePaths: readonly string[]
-  projectRoot: string
-  kind: DiscoveryModuleKind
-}): Promise<unknown[]> {
+async function listFamilyModules(
+  projectRoot: string,
+  kind: DiscoveryModuleKind,
+  directory: readonly string[]
+): Promise<ProjectModule[]> {
+  const paths = await listModuleFiles(join(projectRoot, ...directory))
+  return paths.map((path) => ({ kind, path: relative(projectRoot, path) }))
+}
+
+async function loadFamilyExports(
+  projectRoot: string,
+  kind: DiscoveryModuleKind,
+  directory: readonly string[]
+): Promise<unknown[]> {
+  const project = bundledProject.getStore()
+  if (project) {
+    if (resolve(projectRoot) !== project.projectRoot) {
+      throw new RuntimeError(
+        `Built project discovery is scoped to '${project.projectRoot}', not '${projectRoot}'. ` +
+          "Run the built entry from the project root and use that root in createSixb()."
+      )
+    }
+    return loadModuleExports(project.modules.filter((module) => module.kind === kind))
+  }
+
+  const modules = await listFamilyModules(projectRoot, kind, directory)
+  return loadModuleExports(
+    modules.map((module) => ({
+      ...module,
+      load: () => import(pathToFileURL(resolve(projectRoot, module.path)).href),
+    }))
+  )
+}
+
+async function loadModuleExports(modules: readonly BundledProjectModule[]): Promise<unknown[]> {
   const exportedCandidates: unknown[] = []
   const seen = new Set<unknown>()
 
-  for (const modulePath of options.modulePaths) {
+  for (const module of modules) {
     let moduleNamespace: Record<string, unknown>
     try {
-      moduleNamespace = (await import(pathToFileURL(modulePath).href)) as Record<string, unknown>
+      moduleNamespace = await module.load()
     } catch (error) {
-      const relPath = relative(options.projectRoot, modulePath)
       const reason = error instanceof Error ? error.message : String(error)
-      throw new RuntimeError(`Failed to load ${options.kind} module '${relPath}': ${reason}`)
+      throw new RuntimeError(`Failed to load ${module.kind} module '${module.path}': ${reason}`)
     }
 
     for (const exportedValue of Object.values(moduleNamespace)) {

package/src/bootstrap/index.ts

@@ -1,7 +1,14 @@
-export type { DiscoveredProjectDefinitions } from "./discovery"
+export type {
+  BundledProjectModule,
+  DiscoveredProjectDefinitions,
+  DiscoveryModuleKind,
+  ProjectModule,
+} from "./discovery"
 export {
   discoverOntologySources,
   discoverProjectDefinitions,
+  listProjectModules,
+  withProjectModules,
 } from "./discovery"
 export type {
   GenerateOntologyTypeManifestOptions,