@kindgi/agents 0.0.0-bootstrap.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Kindgi Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,132 @@
-# @kindgi/agents
+# `@kindgi/agents`
 
-A placeholder. Releases come from https://github.com/kindgi/kindgi-sdk.
+Agent definitions and the agent-turn executor for Kindgi. `defineAgent` validates a declarative agent (instructions template, required model capabilities, versioned tool references, retrieval intents, guardrail ids, budgets, conversation and HITL policy) into a plain, serializable `Agent`. `invokeAgent` runs one turn of a conversation as a run of a built-in flow. Storage, model providers, tools, and the flow runtime are all supplied through binding interfaces, which a runtime adapter implements.
+
+## Purpose
+
+Keep an agent a piece of data that can be versioned, stored, and pinned by `{ id, version }`, and keep every side effect behind an interface. Because a turn is a journaled flow run, it can park on a human approval and resume later with the same run id, conversation, and provenance record.
+
+## Exports
+
+- **Defining agents**
+  - **`defineAgent(spec: DefineAgentSpec)`** — returns `Result<Agent, InvalidAgentError>`, collecting every validation issue with a `path` and `message`. `DefineAgentSpec` has the fields of `Agent` except `preferredModel`, with `id` and `version` as plain strings.
+  - **`Agent`** — `id` (`AgentId`), `version` (exact semver), `name`, `description?`, `instructions` (a LiquidJS template), `parameters?` (`PromptParameter[]`), `capabilities` (`Capability[]` from [`@kindgi/capabilities`](../capabilities/); a turn routes on the first entry), `tools`, `retrieval`, `guardrails` (guardrail ids), `preferredProvider?`, `preferredModel?`, `conversationPolicy?`, `budget?`, `tags?`.
+    - **`ToolRef`** — `{ id, version }`, where `version` is an npm-style semver range (`'1.2.3'`, `'^1.2.3'`, `'~1.2.3'`, `'>=1.0.0 <2.0.0'`) resolved at run start against the tenant's tool registry (`ToolRegistry.forTenant`). Bare tool ids are rejected.
+    - **`RetrievalIntent`** — `types`, `scope` (`same-conversation`, `same-project`, `tenant`), `limit?` (default 10), `mode?` (`keyword`, `semantic`, `both`; omitted lists the latest facts of each type).
+    - **`ConversationPolicy`** — `historyLimit?` (prior messages loaded into the prompt), `autoCloseAfterInactiveSeconds?`, `hitlAfterTurns?`, and `hitl?`: a session gate (`afterTurns`), per-tool gates (`tools.default` and `tools.overrides` with modes `never_ask`, `ask_on_first_use`, `always_ask` and an optional `requiredRole`), `defaultReviewerRole`, and `timeoutMs`. Tool gates apply only when `hitl.tools` is set.
+    - **`TurnBudget`** — `maxSteps` (default 8), `maxCostUsd`, `maxWallMs` (default 120 000).
+  - **`PromptParameter`**, **`AgentId`**, **`ConversationId`** (re-exported from [`@kindgi/types`](../types/)).
+  - **`createAgentRegistry(seed?)`** — an in-memory **`AgentRegistry`** keyed by `(id, version)`: `register`, `get(id, version?)`, `getLatest`, `list`, `listVersions`, `unregister`.
+- **Prompt rendering**
+  - **`renderInstructions(agent, context: RenderContext)`** — renders `instructions` in LiquidJS strict mode and returns `{ ok: true, value: RenderResult }` or `{ ok: false, error: PromptRenderError }`. A missing required parameter or unresolved variable is a `missing-parameter` error (`MissingParameterError`), never an empty string; other failures are `render-failure` (`RenderFailureError`). `RenderResult.context` holds every value the template saw.
+  - **`AUTO_INJECTED_VARS`** — `today`, `now`, `agent` (`id`, `name`, `version`), `conversation` (`id`, `turn`). These names are reserved and cannot be declared as parameters.
+- **Running turns**
+  - **`invokeAgent(input: InvokeAgentInput, bindings: InvokeAgentBindings)`** — returns `Promise<Result<AgentTurnResult, InvokeAgentError>>`.
+    - `InvokeAgentInput` — `tenantId`, `projectId`, `agent`, `conversationId` (of a conversation opened with the same agent version), `userMessage`, and optional `parameters`, `participantId`, `abortSignal`, `dryRun` (no conversation, memory or provenance writes; the model call is skipped), `principal` and `authz` (when both are set, tool calls are authorized against the principal; see [`@kindgi/authz`](../authz/)).
+    - `InvokeAgentBindings` — `providerRegistry`, `toolRegistry` (the turn resolves tools on `toolRegistry.forTenant(tenantId)`, so it never sees another tenant's tools), `memoryBinding` (a `MemoryQueryBinding` from [`@kindgi/memory`](../memory/)), `conversationBinding`, `runSnapshotBinding`, and `runBinding` (a `RunBinding` from [`@kindgi/runtime`](../runtime/); optional in the type, required at call time); optionally `tenantPolicy`, `policyRegistry`, `embeddingRegistry`, `embeddingModel`, `onEvent`, `provenance`, `hitl`, `resolveSecret`, and the `GuardrailsBindings` fields (`guardrails`, `checks`, `compliance`). `tenantPolicy` and the policy derived from `policyRegistry` are merged so the result is at least as strict as each (allow lists intersect, deny lists union, the smaller cap wins); the merged policy governs model routing and the models llm-judge guardrails may use.
+    - `AgentTurnResult` — `conversationId`, `turnNumber`, `appended`, `response`, `retrieved`, `violations` (failed guardrails whose action is not `halt` — reported, not carried out), `usage` (`AgentTurnUsage`), `provider`, and optional `provenance`, `dryRun`, `status`. `status: 'suspended'` means the run parked on a HITL approval; the response fields are placeholders until it resumes.
+  - **`resumeAgentTurn(input: ResumeAgentTurnInput, bindings)`** — continues a suspended turn after its approval resolves. The caller passes the `Agent` at the version the run started with.
+    - It rebuilds the turn input from the run snapshot, and the turn's state from the run's journal and the conversation. That state is the environment `setup` resolved, routed to the same provider and model, plus the messages the turn stored, its retrieved facts and its usage.
+    - The turn goes on from the step it parked in. Calls that ran before the park keep their stored results.
+    - Provenance recorded before the park isn't rebuilt.
+    - Errors:
+      - `run-snapshot-missing` when no snapshot was stored;
+      - `run-journal-unavailable` when the journal can't be read;
+      - `capability-routing-failed` when the turn's provider or model is no longer registered or allowed.
+  - **`InvokeAgentError`** — the `AgentError` variants plus `UnresolvedToolError`, `tool-version-unresolvable`, `CapabilityRoutingError`, `ModelInvocationError`, `ToolInvocationError`, `BudgetExceededError` (`kind`: `steps` or `cost`), `AgentTurnAbortedError` (`reason`: `external`, or `timeout` when `maxWallMs` elapses), `HitlRequiredError`, `GuardrailViolationError`, `UnresolvedGuardrailError`, `TenantPolicyUnavailableError` (`code: 'tenant-policy-unavailable'`, with the `policyKind`: a tenant policy the turn must apply could not be evaluated, so the turn fails rather than run without it).
+  - **Streaming** — `bindings.onEvent` (`OnTurnEvent`, sync or async) receives each `TurnEvent`: `turn.started`, `retrieval.completed`, `model.call.started`, `model.call.completed`, `tool.started`, `tool.completed`, `tool.failed`, `agent.message`, `guardrail.violated`, `turn.completed`, `turn.failed`. Each has an exported type (`TurnStartedEvent`, `ToolStartedEvent`, …). Exceptions thrown by the handler are swallowed.
+- **Turn flow**
+  - **`AGENT_TURN_FLOW`** — the [`@kindgi/flow`](../flow/) `Flow` every turn runs, with **`AGENT_TURN_FLOW_ID`** (`'agent.turn'`), **`AGENT_TURN_FLOW_VERSION`** (`'1.1.0'`), **`AGENT_TURN_LOOP_MAX_ITERATIONS`** (32), and one `*_NODE` constant per node id as it appears in run journals: `setup` → `render-prompt` → `persist-user-message` → `run-retrievals` → `build-initial-messages` → `agent-loop` (`model-call` → `dispatch-tools` → `budget-check`) → `evaluate-guardrails` → `persist-final-message` → `persist-provenance` → `compose-result`. Guardrails are evaluated once per turn, on the final response before it is stored; a failed check whose action is `halt` fails the turn with `guardrail-violation`, and the response is never written to the conversation. Failures with any other action (`log-only`, `retry`, `escalate`, `compensate`, or a custom action — guardrail kinds and actions are open strings) are reported in `violations` and as `guardrail.violated` events; the turn does not carry them out.
+  - Steps usable on their own: **`runRetrievals`** with **`RetrievalBindings`** and **`formatRetrievedForPrompt`** (`RetrievedFact` pairs a fact with the intent that fetched it); **`resolveGuardrails`**, **`buildRunTrace`**, **`evaluateGate`** (takes the turn's tenant policy, under which llm-judge guardrails route), **`categorizeOutcomes`**, **`evaluateSessionGate`** (`SessionGateResult`) with **`GuardrailsBindings`**; **`persistProvenance`** with **`ProvenanceBindings`** (`newBuilder`, `emit`, `emitBinding`, `keyProvider`).
+  - **`resolveEffectiveHitlPolicy({ tenant, agent })`** — returns an `EffectiveHitlPolicy`: framework defaults (24 h timeout, `standard` reviewer, `escalate` on timeout) overlaid with the agent's policy, then held to the tenant's `hitl` policy (`tenant`: a `HitlSpec` from [`@kindgi/policy-contract`](../policy-contract/), or `undefined`), which can only tighten: it caps the timeout, raises the reviewer role, and sets `toolFloors` — per tool, a gate is the stricter of the agent's and the tenant's. Each turn resolves it once, evaluating `hitl` through `policyRegistry`; an evaluation that throws fails the turn with `tenant-policy-unavailable`.
+- **Bindings**, implemented by a runtime adapter
+  - **`ConversationBinding`** — `openConversation`, `getConversation`, `listConversations`, `listConversationsPage` (keyset pagination by `openedAt DESC, id DESC` with a `ConversationPageCursor`), `closeConversation`, `deleteConversation`, `appendMessage`, `readMessages`. Inputs: `OpenConversationInput`, `ListConversationsInput`, `ListConversationsPageInput`, `AppendMessageInput`, `ReadMessagesInput`; results: `Conversation`, `ConversationPage`, `ConversationMessage` (`MessageRole`: `user`, `agent`, `tool`, `system`).
+  - **`RunSnapshotBinding`** — `write(RunSnapshotWriteInput)` and `read(tenantId, runId)` of the `RunSnapshotRecord` that `resumeAgentTurn` needs. Writes must be idempotent per run id.
+  - **Postgres support** — Drizzle tables `agentConversations` and `agentRunSnapshots` with their row types (`AgentConversationRow`, `NewAgentConversationRow`, `AgentRunSnapshotRow`, `NewAgentRunSnapshotRow`), `AGENTS_TENANT_SCOPED_TABLES`, `AGENTS_MIGRATIONS_DIR` (absolute path to the bundled SQL migrations), and the `{ v, doc }` JSONB envelope helpers `wrap`, `unwrap`, `unwrapOrThrow`, `CURRENT_AGENTS_PAYLOAD_VERSION` with `EnvelopeError`, `MalformedEnvelopeError`, `UnsupportedPayloadVersionError`.
+- **Errors** — **`AgentError`**: `InvalidAgentError`, `AgentNotFoundError`, `AgentAlreadyRegisteredError`, `AgentVersionMismatchError`, `ConversationNotFoundError`, `ConversationClosedError`, `InvalidMessageError`, `PersistenceError`. Every error carries a `code`.
+
+## Example
+
+```ts
+import { defineAgent, invokeAgent } from '@kindgi/agents';
+import type { InvokeAgentBindings } from '@kindgi/agents';
+import type { ProjectId, TenantId } from '@kindgi/types';
+
+const drafter = defineAgent({
+  id: 'acme.contract-drafter',
+  version: '1.0.0',
+  name: 'Contract Drafter',
+  instructions: 'You draft contract clauses for {{ firmName }}. Today is {{ today }}.',
+  parameters: [{ name: 'firmName', type: 'string' }],
+  capabilities: [{ needs: [{ feature: 'tool-use' }] }],
+  tools: [
+    { id: 'acme.clause-search', version: '^1.0.0' },
+    { id: 'acme.send-email', version: '~2.1.0' },
+  ],
+  retrieval: [{ types: ['acme.clause'], scope: 'same-project', mode: 'keyword', limit: 5 }],
+  guardrails: ['acme.no-pii'],
+  conversationPolicy: {
+    historyLimit: 20,
+    hitl: { tools: { overrides: { 'acme.send-email': 'always_ask' } } },
+  },
+  budget: { maxSteps: 6, maxCostUsd: 0.25, maxWallMs: 60_000 },
+});
+if (drafter.kind === 'err') throw new Error(JSON.stringify(drafter.error.issues));
+const agent = drafter.value;
+
+// `bindings` come from the runtime that hosts the agent, or from your own implementations.
+export async function firstTurn(
+  bindings: InvokeAgentBindings,
+  tenantId: TenantId,
+  projectId: ProjectId,
+  userMessage: string,
+): Promise<string | undefined> {
+  const conversation = await bindings.conversationBinding.openConversation({
+    tenantId,
+    agentId: agent.id,
+    agentVersion: agent.version,
+    title: 'NDA for globex',
+    scope: { tenantId, projectId },
+  });
+  if (conversation.kind === 'err') throw new Error(conversation.error.message);
+
+  const result = await invokeAgent(
+    {
+      tenantId,
+      projectId,
+      agent,
+      conversationId: conversation.value.id,
+      userMessage,
+      parameters: { firmName: 'Acme LLP' },
+    },
+    {
+      ...bindings,
+      onEvent: (event) => {
+        if (event.kind === 'tool.started') console.log(`calling ${event.toolId}@${event.toolVersion}`);
+      },
+    },
+  );
+
+  if (result.kind === 'err') {
+    if (result.error.code === 'budget-exceeded') return `Stopped: ${result.error.kind} budget exceeded`;
+    throw new Error(`${result.error.code}: ${result.error.message}`);
+  }
+  if (result.value.status === 'suspended') return undefined; // waiting for a reviewer; see resumeAgentTurn
+  const { content } = result.value.response;
+  return typeof content === 'string' ? content : JSON.stringify(content);
+}
+```
+
+## Non-goals
+
+- **No storage or model access of its own.** Conversations, messages, run snapshots, memory, provenance, providers, tools, and flow execution all go through the bindings; the package ships Drizzle tables and migrations for Postgres implementations but never opens a database connection.
+- **No tenancy in the agent registry.** `AgentRegistry` is a plain in-memory catalog; multi-tenant deployments keep one registry per tenant or layer isolation on top.
+- **No moving a conversation to a new agent version.** A conversation stays pinned to the agent version it was opened with; invoking it with another version fails with `agent-version-mismatch`, and a closed conversation cannot be reopened.
+
+## Related
+
+- [`@kindgi/sdk`](../sdk/) — re-exports `defineAgent`, `Agent`, and `DefineAgentSpec` from `@kindgi/sdk/define`.
+- [`@kindgi/capabilities`](../capabilities/) — capability declarations and the router that picks a model for each turn.
+- [`@kindgi/tools`](../tools/) and [`@kindgi/guardrails`](../guardrails/) — tool and check definitions referenced by `tools` and `guardrails`.
+- [`@kindgi/memory`](../memory/) and [`@kindgi/provenance`](../provenance/) — the memory binding used for retrieval, and the provenance record built for each turn.
+- [`@kindgi/flow`](../flow/) and [`@kindgi/runtime`](../runtime/) — the flow model and the `RunBinding` that executes the agent-turn flow.

package/dist/agent-turn-flow.d.ts

@@ -0,0 +1,57 @@
+import type { Flow } from '@kindgi/flow';
+/**
+ * The versioned agent-turn flow. Every agent turn — regardless of which
+ * concrete `Agent` is being invoked — executes as a run of this flow
+ * against handlers that close over the specific agent + bindings + input.
+ *
+ * Shape (uses the kernel loop primitive for the model↔tool cycle):
+ *
+ * ```
+ * $start → setup → render-prompt → persist-user-message → run-retrievals
+ *        → build-initial-messages → agent-loop (kernel loop node)
+ *        → evaluate-guardrails → persist-final-message → persist-provenance
+ *        → compose-result → $end
+ * ```
+ *
+ * Guardrails run on the final response before it is stored: a response
+ * a blocking guardrail rejects never reaches the conversation.
+ *
+ * `agent-loop` is a `while+after` (do-while) loop; its body is
+ * `$loop-start → model-call → dispatch-tools → budget-check → $loop-end`.
+ * Exit condition: `iterationOutput.finishedTurn === true`.
+ * `collectAllIterations: true` so post-loop nodes can aggregate every
+ * iteration's per-iteration usage + appended messages.
+ *
+ * Version-locked so historical runs pin to this shape; any
+ * change to the node set or body sub-flow bumps the version and
+ * `resumeRun` refuses to resume old runs against a new flow.
+ */
+export declare const AGENT_TURN_FLOW_ID = "agent.turn";
+export declare const AGENT_TURN_FLOW_VERSION = "1.1.0";
+/**
+ * Safety cap for iterations. Per-agent `maxSteps` is enforced by the
+ * `budget-check` body node — this constant only bounds catastrophic
+ * runaway (model always requests a tool call, no budget-check, no
+ * agent config). Set high enough that no real agent will hit it.
+ */
+export declare const AGENT_TURN_LOOP_MAX_ITERATIONS = 32;
+export declare const SETUP_NODE = "setup";
+export declare const RENDER_PROMPT_NODE = "render-prompt";
+export declare const PERSIST_USER_MESSAGE_NODE = "persist-user-message";
+export declare const RUN_RETRIEVALS_NODE = "run-retrievals";
+export declare const BUILD_INITIAL_MESSAGES_NODE = "build-initial-messages";
+export declare const AGENT_LOOP_NODE = "agent-loop";
+export declare const PERSIST_FINAL_MESSAGE_NODE = "persist-final-message";
+export declare const EVALUATE_GUARDRAILS_NODE = "evaluate-guardrails";
+export declare const PERSIST_PROVENANCE_NODE = "persist-provenance";
+export declare const COMPOSE_RESULT_NODE = "compose-result";
+export declare const MODEL_CALL_NODE = "model-call";
+export declare const DISPATCH_TOOLS_NODE = "dispatch-tools";
+export declare const BUDGET_CHECK_NODE = "budget-check";
+/**
+ * The compiled + validated flow. Cached — the loader is called once
+ * at module load. Throws on module load if the constant is malformed
+ * (should be caught by tests immediately).
+ */
+export declare const AGENT_TURN_FLOW: Flow;
+//# sourceMappingURL=agent-turn-flow.d.ts.map

package/dist/agent-turn-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-turn-flow.d.ts","sourceRoot":"","sources":["../src/agent-turn-flow.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAC/C,eAAO,MAAM,uBAAuB,UAAU,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAGjD,eAAO,MAAM,UAAU,UAAU,CAAC;AAClC,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAClD,eAAO,MAAM,yBAAyB,yBAAyB,CAAC;AAChE,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AACpD,eAAO,MAAM,2BAA2B,2BAA2B,CAAC;AACpE,eAAO,MAAM,eAAe,eAAe,CAAC;AAC5C,eAAO,MAAM,0BAA0B,0BAA0B,CAAC;AAClE,eAAO,MAAM,wBAAwB,wBAAwB,CAAC;AAC9D,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AAC5D,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAGpD,eAAO,MAAM,eAAe,eAAe,CAAC;AAC5C,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AACpD,eAAO,MAAM,iBAAiB,iBAAiB,CAAC;AA8GhD;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,IAQ1B,CAAC"}

package/dist/agent-turn-flow.js

@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2026 Kindgi Inc.
+import { loadFlow } from '@kindgi/flow';
+/**
+ * The versioned agent-turn flow. Every agent turn — regardless of which
+ * concrete `Agent` is being invoked — executes as a run of this flow
+ * against handlers that close over the specific agent + bindings + input.
+ *
+ * Shape (uses the kernel loop primitive for the model↔tool cycle):
+ *
+ * ```
+ * $start → setup → render-prompt → persist-user-message → run-retrievals
+ *        → build-initial-messages → agent-loop (kernel loop node)
+ *        → evaluate-guardrails → persist-final-message → persist-provenance
+ *        → compose-result → $end
+ * ```
+ *
+ * Guardrails run on the final response before it is stored: a response
+ * a blocking guardrail rejects never reaches the conversation.
+ *
+ * `agent-loop` is a `while+after` (do-while) loop; its body is
+ * `$loop-start → model-call → dispatch-tools → budget-check → $loop-end`.
+ * Exit condition: `iterationOutput.finishedTurn === true`.
+ * `collectAllIterations: true` so post-loop nodes can aggregate every
+ * iteration's per-iteration usage + appended messages.
+ *
+ * Version-locked so historical runs pin to this shape; any
+ * change to the node set or body sub-flow bumps the version and
+ * `resumeRun` refuses to resume old runs against a new flow.
+ */
+export const AGENT_TURN_FLOW_ID = 'agent.turn';
+export const AGENT_TURN_FLOW_VERSION = '1.1.0';
+/**
+ * Safety cap for iterations. Per-agent `maxSteps` is enforced by the
+ * `budget-check` body node — this constant only bounds catastrophic
+ * runaway (model always requests a tool call, no budget-check, no
+ * agent config). Set high enough that no real agent will hit it.
+ */
+export const AGENT_TURN_LOOP_MAX_ITERATIONS = 32;
+// Outer node ids.
+export const SETUP_NODE = 'setup';
+export const RENDER_PROMPT_NODE = 'render-prompt';
+export const PERSIST_USER_MESSAGE_NODE = 'persist-user-message';
+export const RUN_RETRIEVALS_NODE = 'run-retrievals';
+export const BUILD_INITIAL_MESSAGES_NODE = 'build-initial-messages';
+export const AGENT_LOOP_NODE = 'agent-loop';
+export const PERSIST_FINAL_MESSAGE_NODE = 'persist-final-message';
+export const EVALUATE_GUARDRAILS_NODE = 'evaluate-guardrails';
+export const PERSIST_PROVENANCE_NODE = 'persist-provenance';
+export const COMPOSE_RESULT_NODE = 'compose-result';
+// Loop body node ids.
+export const MODEL_CALL_NODE = 'model-call';
+export const DISPATCH_TOOLS_NODE = 'dispatch-tools';
+export const BUDGET_CHECK_NODE = 'budget-check';
+/**
+ * JSON Schema (draft 2020-12) for each iteration's `$loop-end` output.
+ * See `AgentTurnIterationOutput` in the handlers module for the TS
+ * mirror.
+ */
+const iterationOutputSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: [
+        'finishReason',
+        'message',
+        'iterationAppended',
+        'iterationUsage',
+        'provider',
+        'finishedTurn',
+        'nextMessages',
+    ],
+    properties: {
+        finishReason: {
+            type: 'string',
+            enum: ['stop', 'length', 'tool-use', 'content-filter', 'error'],
+        },
+        message: { type: 'object' },
+        iterationAppended: { type: 'array' },
+        iterationUsage: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['promptTokens', 'completionTokens', 'costUsd'],
+            properties: {
+                promptTokens: { type: 'integer', minimum: 0 },
+                completionTokens: { type: 'integer', minimum: 0 },
+                costUsd: { type: 'number', minimum: 0 },
+            },
+        },
+        provider: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['id', 'model'],
+            properties: {
+                id: { type: 'string' },
+                model: { type: 'string' },
+            },
+        },
+        finishedTurn: { type: 'boolean' },
+        nextMessages: { type: 'array' },
+        /** Populated when finishReason='error' from budget-check or dispatch failure. */
+        errorPayload: { type: 'object' },
+    },
+};
+const rawGraph = {
+    id: AGENT_TURN_FLOW_ID,
+    version: AGENT_TURN_FLOW_VERSION,
+    name: 'Agent turn',
+    description: 'Framework-grade agent turn execution. One run per turn. Model↔tool cycle uses the kernel loop primitive.',
+    nodes: [
+        { id: SETUP_NODE, kind: 'tool', ref: 'inline' },
+        { id: RENDER_PROMPT_NODE, kind: 'tool', ref: 'inline' },
+        { id: PERSIST_USER_MESSAGE_NODE, kind: 'tool', ref: 'inline' },
+        { id: RUN_RETRIEVALS_NODE, kind: 'tool', ref: 'inline' },
+        { id: BUILD_INITIAL_MESSAGES_NODE, kind: 'tool', ref: 'inline' },
+        {
+            id: AGENT_LOOP_NODE,
+            kind: 'loop',
+            loopKind: 'while',
+            evaluationTiming: 'after',
+            maxIterations: AGENT_TURN_LOOP_MAX_ITERATIONS,
+            exitCondition: {
+                op: 'truthy',
+                value: { path: 'iterationOutput.finishedTurn' },
+            },
+            outputSchema: iterationOutputSchema,
+            collectAllIterations: true,
+            body: {
+                nodes: [
+                    { id: MODEL_CALL_NODE, kind: 'tool', ref: 'inline' },
+                    { id: DISPATCH_TOOLS_NODE, kind: 'tool', ref: 'inline' },
+                    { id: BUDGET_CHECK_NODE, kind: 'tool', ref: 'inline' },
+                ],
+                edges: [
+                    { id: 'body-e1', from: '$loop-start', to: MODEL_CALL_NODE },
+                    { id: 'body-e2', from: MODEL_CALL_NODE, to: DISPATCH_TOOLS_NODE },
+                    { id: 'body-e3', from: DISPATCH_TOOLS_NODE, to: BUDGET_CHECK_NODE },
+                    { id: 'body-e4', from: BUDGET_CHECK_NODE, to: '$loop-end' },
+                ],
+            },
+        },
+        { id: EVALUATE_GUARDRAILS_NODE, kind: 'tool', ref: 'inline' },
+        { id: PERSIST_FINAL_MESSAGE_NODE, kind: 'tool', ref: 'inline' },
+        { id: PERSIST_PROVENANCE_NODE, kind: 'tool', ref: 'inline' },
+        { id: COMPOSE_RESULT_NODE, kind: 'tool', ref: 'inline' },
+    ],
+    edges: [
+        { id: 'e0', from: '$start', to: SETUP_NODE },
+        { id: 'e1', from: SETUP_NODE, to: RENDER_PROMPT_NODE },
+        { id: 'e2', from: RENDER_PROMPT_NODE, to: PERSIST_USER_MESSAGE_NODE },
+        { id: 'e3', from: PERSIST_USER_MESSAGE_NODE, to: RUN_RETRIEVALS_NODE },
+        { id: 'e4', from: RUN_RETRIEVALS_NODE, to: BUILD_INITIAL_MESSAGES_NODE },
+        { id: 'e5', from: BUILD_INITIAL_MESSAGES_NODE, to: AGENT_LOOP_NODE },
+        { id: 'e6', from: AGENT_LOOP_NODE, to: EVALUATE_GUARDRAILS_NODE },
+        { id: 'e7', from: EVALUATE_GUARDRAILS_NODE, to: PERSIST_FINAL_MESSAGE_NODE },
+        { id: 'e8', from: PERSIST_FINAL_MESSAGE_NODE, to: PERSIST_PROVENANCE_NODE },
+        { id: 'e9', from: PERSIST_PROVENANCE_NODE, to: COMPOSE_RESULT_NODE },
+        { id: 'e10', from: COMPOSE_RESULT_NODE, to: '$end' },
+    ],
+};
+/**
+ * The compiled + validated flow. Cached — the loader is called once
+ * at module load. Throws on module load if the constant is malformed
+ * (should be caught by tests immediately).
+ */
+export const AGENT_TURN_FLOW = (() => {
+    const r = loadFlow(rawGraph);
+    if (r.kind === 'err') {
+        throw new Error(`AGENT_TURN_FLOW failed to load — this is a bug in agent-turn-flow.ts: ${JSON.stringify(r.error)}`);
+    }
+    return r.value;
+})();
+//# sourceMappingURL=agent-turn-flow.js.map

package/dist/agent-turn-flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-turn-flow.js","sourceRoot":"","sources":["../src/agent-turn-flow.ts"],"names":[],"mappings":"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"}