@felspar/sdk 0.2.0 → 0.2.1

package/README.md

@@ -1,20 +1,10 @@
 # @felspar/sdk
 
-Felspar is a shared, versioned decision system for enterprise agents. A
-company's approved meaning, the evidence a decision needs and the decision
-itself travel together in a released Decision Pack. Agents ask Felspar for a
-decision, get a receipt they can verify, and act only on what Felspar decided.
-
-This package connects an agent to Felspar: an [Eve](https://github.com/vercel/eve)
-connection in two lines, a TypeScript client for the hosted Felspar API, an
-action gate that keeps an agent's tools from acting without a verified Felspar
-decision, and the agent skill for running any Felspar job. It runs on Node.js
-24 or later, and its only dependency is `zod`. The SDK is a transport client:
-decisions and policy stay with the Felspar service and the released pack, and
-the SDK does not reimplement them.
-
-The modules under `draft/` may change between minor versions while the API
-settles, before 1.0.
+Felspar is a shared, versioned decision system for enterprise agents. A company's approved meaning, the evidence a decision needs and the decision itself travel together in a released Decision Pack. Agents ask Felspar for a decision, get a receipt they can verify, and act only on what Felspar decided.
+
+This package connects an agent to Felspar: an [Eve](https://github.com/vercel/eve) connection in two lines, a TypeScript client for the hosted Felspar API, an action gate that keeps an agent's tools from acting without a verified Felspar decision, and the agent skill for running any Felspar job. It runs on Node.js 24 or later, and its only dependency is `zod`. The SDK is a transport client: decisions and policy stay with the Felspar service and the released pack, and the SDK does not reimplement them.
+
+The modules under `draft/` may change between minor versions while the API settles, before 1.0.
 
 ## Install
 
@@ -32,12 +22,7 @@ import { felsparConnection } from "@felspar/sdk/eve";
 export default defineMcpClientConnection(felsparConnection());
 ```
 
-The agent gets Felspar's `get_job_requirements`, `get_job_decision` and
-`check_output` tools and nothing else. The key is the agent's own, created on
-the Felspar web page (Workspace → Agents) and read from `FELSPAR_AGENT_KEY`
-when Eve connects; the endpoint is `FELSPAR_MCP_URL`, or production. Pass
-`{ url, agentKey, description }` to override them. Add the skill (below) so the
-agent knows the method.
+The agent gets Felspar's `list_jobs`, `get_job_requirements`, `get_job_decision` and `check_output` tools and nothing else. The key is the agent's own, created on the Felspar web page (Workspace → Agents) and read from `FELSPAR_AGENT_KEY` when Eve connects; the endpoint is `FELSPAR_MCP_URL`, or production. Pass `{ url, agentKey, description }` to override them. Add the skill (below) so the agent knows the method.
 
 ## Hosted client
 
@@ -68,18 +53,18 @@ const response = await felspar.resolveFacts(releaseId, {
 if (response.status === "ready") {
   console.log(response.result?.outcome, response.result?.receipt);
 }
+
+// The jobs this agent key may run, by ID.
+const { jobs } = await felspar.listJobs();
 ```
 
-A refused request throws `FelsparRequestError` with the HTTP `status` and the
-service's `refusal` (its `error` code and, where there is one, a `fix`).
+How a case is identified comes from the job's description (`identity`): send `entityId` for the record's own ID (`provided`), `identity` field values (`fields`), or nothing (`content`, and the first decision of an `issued` job). The result's `case` gives the case's `id` and `mode`; send `case.id` as `entityId` for every later decision on the same case. Results are typed (`FelsparJobResult`): `case`, `subject` with its `related` records, `escalation` (`id`, `trigger`, `why`) and `missing` for a gap.
+
+A refused request throws `FelsparRequestError` with the HTTP `status` and the service's `refusal` (its `error` code, where there is one a `fix`, and any `escalation` it names, such as for `attempt_limit_reached`).
 
 ## Action gate
 
-The gate sits in front of a tool that acts, such as writing an email draft or
-replying to a ticket. It allows a call only when the call's fields are allowed,
-the call is about a case Felspar decided on in this session, Felspar
-re-verifies that decision's receipt, and the decided outcome permits the tool.
-Any error, and anything unknown or ambiguous, denies.
+The gate sits in front of a tool that acts, such as writing an email draft or replying to a ticket. It allows a call only when the call's fields are allowed, the call is about a case Felspar decided on in this session, Felspar re-verifies that decision's receipt, and the decided outcome permits the tool. Any error, and anything unknown or ambiguous, denies.
 
 ```ts
 import {
@@ -110,31 +95,16 @@ const gate = createActionGate({
 
 What a tool may do comes from the released pack, not from the gate's config:
 
-- `writes` names the output the tool writes, by its id in the pack. The call is
-  allowed only when the released job description lists that output under the
-  outcome Felspar's replay reports. (A rule may give `outcomes`, a list of
-  outcome ids, instead; exactly one of the two.)
-- `entity` says which case a call is about. By default, every recipient's
-  email domain must belong to the one company Felspar decided on. With
-  `{ field }`, that input field must hold the decision's `entity_id` (such as a
-  ticket ID), trimmed and otherwise exact, case included, as Felspar keys
-  cases (`HC-1201` and `hc-1201` are two cases). Only email domains match
-  without case.
-  Recipients are then not tied to the case, so a tool that can address anyone
-  should also limit them (`testRecipients`, or the tool's own settings).
-- `outputCheck` requires that Felspar passed exactly the text the call sends
-  for that decision (`check_output`); with `writes`, for that output.
-
-A denial is `{ allow: false, reason, escalate? }`. `escalate` is the company's
-next step, quoted from the released description: the outcome's next step when
-the outcome doesn't permit the tool, or what to do when nothing is decided. For
-a missing or failed output check it is the fixed instruction to fix what
-`check_output` flagged and check again. It is absent when the description
-doesn't say. Every adapter below shows it to the
-model with the reason.
-
-Then connect the gate to your agent framework. Tool names must match exactly
-as the runtime reports them.
+- `writes` names the output the tool writes, by its id in the pack. The call is allowed only when the released job description lists that output under the outcome Felspar's replay reports. (A rule may give `outcomes`, a list of outcome ids, instead; exactly one of the two.)
+- Which case a call is about comes from the released job's subject and identity. A decision is recorded by the `case.id` Felspar's result names (so an agent that sends no `entity_id`, for an issued, fields or content job, still gets one), and Felspar's replay must name the same case ID and mode. By default:
+  - for a job whose subject is a provided, case-insensitive ID such as a web domain (or a release with no subject), every recipient's email domain must belong to the one company Felspar decided on; a decided ID that isn't a company domain allows no recipient, so give such a rule an entity field;
+  - for any other job, the call is about the one case decided in the session for this job; with several, the call is denied until the rule names a field.
+- `entity: { field }` overrides that: the input field must hold the case's ID, the record's own ID (such as a ticket ID) or the `case.id` Felspar issued or derived, trimmed and matched by the subject's match rule (exact unless the subject is case-insensitive; with no subject, `HC-1201` and `hc-1201` are two cases). Recipients are then not tied to the case, so a tool that can address anyone should also limit them (`testRecipients`, or the tool's own settings).
+- `outputCheck` requires that Felspar passed exactly the text the call sends for that decision (`check_output`); with `writes`, for that output.
+
+A denial is `{ allow: false, reason, escalate?, escalation? }`. `escalate` is the company's next step, quoted from the released description: the outcome's next step when the outcome doesn't permit the tool, or what to do when nothing is decided. For a missing or failed output check it is the fixed instruction to fix what `check_output` flagged and check again. `escalation` is the hand-off the policy names: `{ id, trigger, why }`, with the id from Felspar's replay of the outcome (or the job's unresolved path) and `why` quoted from the release. Both are absent when the release doesn't say. Every adapter below shows them to the model with the reason.
+
+Then connect the gate to your agent framework. Tool names must match exactly as the runtime reports them.
 
 ### Eve
 
@@ -174,28 +144,20 @@ toolInputGuardrails: [felsparToolInputGuardrail(gate, { sessionOf })],
 toolOutputGuardrails: [felsparDecisionOutputGuardrail(gate, { sessionOf })],
 ```
 
-Outside an agent framework,
-`checkAction({ rules, toolName, input, decisions, verify, describe })` returns
-the same verdict.
+Outside an agent framework, `checkAction({ rules, toolName, input, decisions, verify, describe })` returns the same verdict.
 
-A Felspar receipt records what Felspar decided from the evidence it was given.
-It is not a factual, legal or security certification, and a passed output
-check means the text follows the released rules, not that it is true or
-approved to send.
+A Felspar receipt records what Felspar decided from the evidence it was given. It is not a factual, legal or security certification, and a passed output check means the text follows the released rules, not that it is true or approved to send.
 
 ## Agent skill
 
-The package ships the skill that teaches an agent the method for any Felspar
-job: get the requirements, gather exact evidence, get the decision, write and
-check what the decision asks for, and escalate with the company's next step.
+The package ships the skill that teaches an agent the method for any Felspar job: get the requirements, gather exact evidence, get the decision, write and check what the decision asks for, and escalate with the company's next step.
 
 ```bash
 npx @felspar/sdk skill        # writes agent/skills/felspar/SKILL.md
 npx @felspar/sdk skill .claude --force
 ```
 
-The directory defaults to `agent`, where an Eve agent keeps its skills; an
-existing copy is kept unless you pass `--force`.
+The directory defaults to `agent`, where an Eve agent keeps its skills; an existing copy is kept unless you pass `--force`.
 
 ## Documentation
 

package/dist/chunks/{chunk-247XZ6IY.js → chunk-B4BWUYQY.js}

@@ -2,7 +2,7 @@ import {
   denialText,
   entityIdOf,
   jobOf
-} from "./chunk-IY6A2423.js";
+} from "./chunk-Y6KRRIQI.js";
 
 // src/draft-action-gate-eve.ts
 function felsparGate(gate) {
@@ -22,11 +22,10 @@ function felsparDecisionEvents(gate) {
       return;
     }
     for (const action of actions) {
-      const entity = entityIdOf(action.input);
-      if (entity !== void 0 && gate.isDecisionTool(action.toolName ?? "")) {
-        gate.decisions.noteRequest(action.callId, entity);
-      }
       const job = jobOf(action.input);
+      if (gate.isDecisionTool(action.toolName ?? "")) {
+        gate.decisions.noteRequest(action.callId, { entity: entityIdOf(action.input), job });
+      }
       if (job !== void 0 && gate.isOutputCheckTool(action.toolName ?? "")) {
         checks.set(action.callId, job);
       }

package/dist/chunks/{chunk-HACK7D24.js → chunk-XLKRU5RA.js}

@@ -5060,6 +5060,35 @@ var HostedOutputCheckReplySchema = z56.object({
   decision: z56.object({ executionId: z56.string(), receiptDigest: digestText }),
   actionAuthorized: z56.literal(false)
 }).loose();
+var quotedWords = z56.object({ text: z56.string() }).loose();
+var FelsparCaseSchema = z56.object({ id: z56.string().min(1).max(200), mode: z56.enum(identityModes) });
+var FelsparRelatedSchema = z56.object({
+  relationship: z56.string(),
+  subject: z56.string(),
+  id: z56.string(),
+  questions: z56.array(z56.string())
+});
+var FelsparResultSubjectSchema = z56.object({
+  type: z56.string(),
+  id: z56.string(),
+  related: z56.array(FelsparRelatedSchema)
+});
+var FelsparEscalationSchema = z56.object({
+  id: z56.string().min(1).max(200),
+  trigger: z56.enum(escalationTriggers),
+  why: quotedWords
+});
+var FelsparJobResultSchema = HostedJobResultSchema.extend({
+  result: HostedJobResultSchema.shape.result.unwrap().extend({
+    case: FelsparCaseSchema.optional(),
+    subject: FelsparResultSubjectSchema.optional(),
+    escalation: FelsparEscalationSchema.optional(),
+    missing: z56.array(z56.string()).optional()
+  }).nullable()
+});
+var FelsparJobListSchema = z56.object({
+  jobs: z56.array(z56.object({ id: z56.string().min(1).max(200) })).max(256)
+});
 var hostedPartsContentType = "application/x.felspar-content-parts";
 async function partsBody(value) {
   const packed = await packContentParts(value);
@@ -5067,10 +5096,10 @@ async function partsBody(value) {
 }
 async function factsRequest(value, describeRelease) {
   if (typeof value.expectedReleaseDigest === "string") {
-    return HostedFactsJobInputSchema.parse({ mode: "facts", ...value });
+    return HostedFactsRequestSchema.parse({ mode: "facts", ...value });
   }
   const described = await describeRelease(HostedObjectSchema.shape.id.parse(value.jobId));
-  return HostedFactsJobInputSchema.parse({
+  return HostedFactsRequestSchema.parse({
     mode: "facts",
     ...value,
     expectedReleaseDigest: described.release.releaseDigest
@@ -5112,16 +5141,24 @@ ${jobId}`;
 }
 var refusalCode = z56.string().regex(/^[a-z][a-z_]{2,63}$/u);
 var fieldPath = z56.array(z56.string().max(256)).max(32);
+var refusalEscalationSchema = z56.object({
+  id: z56.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]{0,199}$/u),
+  trigger: z56.enum(escalationTriggers),
+  why: z56.object({ text: z56.string().max(2e4) })
+});
 var refusalSchema = z56.object({
   error: refusalCode,
   path: fieldPath.optional(),
   currentReleaseDigest: z56.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
   retryAfterSeconds: z56.number().int().min(1).max(3600).optional(),
+  escalation: z56.unknown().optional(),
   issues: z56.array(z56.object({ code: refusalCode, path: fieldPath })).max(64).optional()
-}).transform((value) => {
+}).transform(({ escalation: named, ...value }) => {
   const fix = hostedRefusalFix(value.error);
+  const escalation = refusalEscalationSchema.safeParse(named).data;
   return {
     ...value,
+    ...escalation !== void 0 && { escalation },
     ...fix !== null && { fix },
     ...value.issues && {
       issues: value.issues.map((issue) => {
@@ -5172,6 +5209,18 @@ function outputCheckCalls(call) {
     readOutputCheck: async (job, checkId) => await call(`${checksOf(job)}/${encodeURIComponent(objectId.parse(checkId))}`, HostedOutputCheckReplySchema)
   };
 }
+function agentCalls(call) {
+  const objectId = HostedObjectSchema.shape.id;
+  return {
+    listJobs: async () => await call("/v0/jobs", FelsparJobListSchema),
+    resolveJob: async (id12, value) => {
+      const input = HostedSuppliedJobInputSchema.parse(value);
+      const releaseId = objectId.parse(id12);
+      const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
+      return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);
+    }
+  };
+}
 function createHostedFelsparClient(configuration) {
   const origin = new URL(configuration.origin);
   const invalid = [
@@ -5218,17 +5267,12 @@ function createHostedFelsparClient(configuration) {
     verifyReceipt: async (executionObjectId, value) => await call(`/v0/executions/${encodeURIComponent(objectId.parse(executionObjectId))}/verify`, HostedReceiptVerificationSchema, HostedReceiptVerificationInputSchema.parse(value)),
     ...outputCheckCalls(call),
     executeJob: async (id12, value) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id12))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value)),
+    ...agentCalls(call),
     resolveFacts: async (id12, value) => {
       const releaseId = objectId.parse(id12);
       const input = await factsRequest(value, async (jobId) => await describe(releaseId, jobId));
       const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
-      return pinnedResult(await call(path3, HostedJobResultSchema, input), releaseId, input);
-    },
-    resolveJob: async (id12, value) => {
-      const input = HostedSuppliedJobInputSchema.parse(value);
-      const releaseId = objectId.parse(id12);
-      const response = await call(`/v0/releases/${encodeURIComponent(releaseId)}/jobs`, HostedJobResultSchema, input);
-      return pinnedResult(response, releaseId, input);
+      return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);
     }
   };
 }