@felspar/sdk 0.3.0 → 0.4.0

package/dist/chunks/{chunk-2RV7RPXW.js → chunk-ZHMUQJT2.js}

@@ -1,6 +1,6 @@
 import {
   createHostedFelsparClient
-} from "./chunk-3YVYBD4H.js";
+} from "./chunk-MIPPJBXB.js";
 
 // src/draft-action-gate-outputs.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -707,7 +707,8 @@ function denialText(verdict) {
     const why = escalation.why === null ? "" : `: ${escalation.why}`;
     parts.push(`Escalation ${escalation.id} (${escalation.trigger})${why}`);
   }
-  return parts.join(". ");
+  parts.push("Don't retry or rephrase this call to get around the gate");
+  return `${parts.map((part) => part.endsWith(".") ? part.slice(0, -1) : part).join(". ")}.`;
 }
 function gatedRule(rules, toolName) {
   return Object.hasOwn(rules.tools, toolName) ? rules.tools[toolName] : void 0;

package/dist/draft-action-gate-claude.js

@@ -2,8 +2,8 @@ import {
   denialText,
   entityIdOf,
   jobOf
-} from "./chunks/chunk-2RV7RPXW.js";
-import "./chunks/chunk-3YVYBD4H.js";
+} from "./chunks/chunk-ZHMUQJT2.js";
+import "./chunks/chunk-MIPPJBXB.js";
 
 // src/draft-action-gate-claude.ts
 function felsparPreToolUse(gate) {

package/dist/draft-action-gate-eve.js

@@ -1,9 +1,9 @@
 import {
   felsparDecisionEvents,
   felsparGate
-} from "./chunks/chunk-7HN5KUTJ.js";
-import "./chunks/chunk-2RV7RPXW.js";
-import "./chunks/chunk-3YVYBD4H.js";
+} from "./chunks/chunk-FVPYJVF5.js";
+import "./chunks/chunk-ZHMUQJT2.js";
+import "./chunks/chunk-MIPPJBXB.js";
 export {
   felsparDecisionEvents,
   felsparGate

package/dist/draft-action-gate-openai.js

@@ -2,8 +2,8 @@ import {
   denialText,
   entityIdOf,
   jobOf
-} from "./chunks/chunk-2RV7RPXW.js";
-import "./chunks/chunk-3YVYBD4H.js";
+} from "./chunks/chunk-ZHMUQJT2.js";
+import "./chunks/chunk-MIPPJBXB.js";
 
 // src/draft-action-gate-openai.ts
 function argumentsOf(text) {

package/dist/draft-action-gate.js

@@ -16,8 +16,8 @@ import {
   outputCheckFromResult,
   outputTextDigest,
   sharedDomains
-} from "./chunks/chunk-2RV7RPXW.js";
-import "./chunks/chunk-3YVYBD4H.js";
+} from "./chunks/chunk-ZHMUQJT2.js";
+import "./chunks/chunk-MIPPJBXB.js";
 export {
   checkAction,
   createActionGate,

package/dist/draft-hosted-client.js

@@ -1,7 +1,7 @@
 import {
   FelsparRequestError,
   createHostedFelsparClient
-} from "./chunks/chunk-3YVYBD4H.js";
+} from "./chunks/chunk-MIPPJBXB.js";
 export {
   FelsparRequestError,
   createHostedFelsparClient

package/dist/eve.js

@@ -1,9 +1,9 @@
 import {
   felsparDecisionEvents,
   felsparGate
-} from "./chunks/chunk-7HN5KUTJ.js";
-import "./chunks/chunk-2RV7RPXW.js";
-import "./chunks/chunk-3YVYBD4H.js";
+} from "./chunks/chunk-FVPYJVF5.js";
+import "./chunks/chunk-ZHMUQJT2.js";
+import "./chunks/chunk-MIPPJBXB.js";
 
 // src/eve.ts
 var felsparMcpUrl = "https://mcp.felspar.ai/mcp";

package/dist/types/draft-hosted-client.d.ts

@@ -147,6 +147,7 @@ declare const refusalSchema: z.ZodPipe<z.ZodObject<{
         code: string;
         path: string[];
     }[] | undefined;
+    recovery?: "escalate" | "fix_input" | "retry";
     fix?: string;
     escalation?: {
         id: string;
@@ -191,6 +192,512 @@ export declare function createHostedFelsparClient(configuration: {
             id: string;
         }[];
     }>;
+    describeCurrentJob: (job: string) => Promise<{
+        schema: "felspar.hosted-job-description.draft/v0";
+        job: string;
+        trustDomain: string;
+        release: {
+            releaseId: string;
+            releaseDigest: string;
+            materialDigest: string;
+            expectedAuthorityDigest: string;
+        };
+        resolutionPolicy: "relative-date-required-types/direct-overrides/v5" | "relational-required-types/direct-overrides/v4" | "scored-required-types/mandatory-gates/v6" | "windowed-required-types/mandatory-gates/v7" | "conditional-required-types/direct-overrides/v3" | "strict-required-types/direct-overrides/v2" | "strict-required-values/direct-overrides/v1";
+        questions: {
+            definition: {
+                key: string;
+                contentDigest: string;
+                sourceLocator: string;
+                allowedValues: string[];
+            } | {
+                key: string;
+                contentDigest: string;
+                sourceLocator: string;
+                valueRule: {
+                    type: "boolean";
+                };
+            } | {
+                key: string;
+                contentDigest: string;
+                sourceLocator: string;
+                valueRule: {
+                    type: "number";
+                    integer: boolean;
+                    minimum: number;
+                    maximum: number;
+                };
+                unit: string;
+            } | {
+                key: string;
+                contentDigest: string;
+                sourceLocator: string;
+                valueRule: {
+                    type: "date";
+                };
+            };
+            evidencePolicy: {
+                maxAgeMs: number;
+                allowedSourceClasses: string[];
+                trustDomain: string;
+            };
+            key: string;
+            type: "number" | "boolean" | "date" | "enum";
+            meaning: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            };
+            answer: {
+                send: "text" | "text_or_value";
+                valueFormat: "number" | "calendar-date" | null;
+                interpretation: "classified" | "exact_read" | "unsupported";
+                threshold: number | null;
+                applies: "always" | "conditional";
+                dependsOn: string[];
+                appliesWhen: string | null;
+                reading?: {
+                    version: "felspar.exact-number/v2";
+                    unit: {
+                        kind: "currency";
+                        code: string;
+                    } | {
+                        kind: "percent";
+                    } | {
+                        kind: "count";
+                        words: string[];
+                    };
+                    numberStyle: "1,234.56" | "1.234,56" | "1 234,56" | "1'234.56";
+                } | {
+                    version: "felspar.exact-date/v2";
+                    dateOrder: "unstated" | "month-first" | "day-first";
+                } | undefined;
+            };
+            requiredWhen?: ({
+                key: string;
+                relativeDate: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    anchorKey: string;
+                    offsetDays: number;
+                    calendar: {
+                        kind: "business_days";
+                        id: string;
+                        version: string;
+                        validFrom: string;
+                        validThrough: string;
+                        workingWeekdays: number[];
+                        holidays: string[];
+                    } | {
+                        kind: "calendar_days";
+                    };
+                };
+            } | {
+                key: string;
+                relativeToDecision: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    offsetDays: number;
+                    timeZone: string;
+                };
+            } | {
+                key: string;
+                equals: string | boolean;
+            } | {
+                key: string;
+                oneOf: string[];
+            } | {
+                key: string;
+                compare: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    value: number;
+                };
+            } | {
+                key: string;
+                compareFact: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    key: string;
+                };
+            } | {
+                key: string;
+                compareDate: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    value: string;
+                };
+            })[] | undefined;
+            answers?: {
+                value: string;
+                meaning: string | null;
+                inclusions: string[];
+                exclusions: string[];
+                examples: string[];
+                edgeCases: string[];
+            }[] | undefined;
+            whereToLook?: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            }[] | undefined;
+            about?: {
+                relationship: string;
+                subject: string;
+            } | undefined;
+        }[];
+        rules: {
+            id: string;
+            sourceLocator: string;
+            contentDigest: string;
+            when: ({
+                key: string;
+                relativeDate: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    anchorKey: string;
+                    offsetDays: number;
+                    calendar: {
+                        kind: "business_days";
+                        id: string;
+                        version: string;
+                        validFrom: string;
+                        validThrough: string;
+                        workingWeekdays: number[];
+                        holidays: string[];
+                    } | {
+                        kind: "calendar_days";
+                    };
+                };
+            } | {
+                key: string;
+                relativeToDecision: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    offsetDays: number;
+                    timeZone: string;
+                };
+            } | {
+                key: string;
+                equals: string | boolean;
+            } | {
+                key: string;
+                oneOf: string[];
+            } | {
+                key: string;
+                compare: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    value: number;
+                };
+            } | {
+                key: string;
+                compareFact: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    key: string;
+                };
+            } | {
+                key: string;
+                compareDate: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    value: string;
+                };
+            })[];
+            outcome: string;
+            overrides: string[];
+            text: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            };
+            scoreRange?: {
+                minimumUnits: number;
+                maximumUnits: number;
+            } | undefined;
+            priority?: number | undefined;
+        }[];
+        outcomes: {
+            id: string;
+            meaning: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            } | null;
+            nextStep?: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            } | null | undefined;
+            outputs?: {
+                id: string;
+                what: {
+                    text: string;
+                    locator: string;
+                };
+                maxCharacters: number;
+                checks: {
+                    check: string;
+                    rule: string | null;
+                    must: string;
+                }[];
+                context?: {
+                    text: string;
+                    locator: string;
+                    id: string;
+                }[] | undefined;
+            }[] | undefined;
+            escalate?: string | undefined;
+        }[];
+        guidance: {
+            gather: string;
+        };
+        input: {
+            jsonSchema: Record<string, unknown>;
+            example: {
+                mode: "facts";
+                executionId: string;
+                expectedReleaseDigest: string;
+                jobId: string;
+                entityId: string;
+                facts: Record<string, {
+                    text: string;
+                    source: {
+                        class: string;
+                        id: string;
+                        observedAt: string;
+                        revision?: string | undefined;
+                        locator?: string | undefined;
+                        sensitivity?: string | undefined;
+                    };
+                    about?: string | undefined;
+                } | {
+                    text: string;
+                    source: {
+                        class: string;
+                        id: string;
+                        observedAt: string;
+                        revision?: string | undefined;
+                        locator?: string | undefined;
+                        sensitivity?: string | undefined;
+                    };
+                    about?: string | undefined;
+                }[] | {
+                    value: string | number | boolean;
+                    source: {
+                        class: string;
+                        id: string;
+                        observedAt: string;
+                        revision?: string | undefined;
+                        locator?: string | undefined;
+                        sensitivity?: string | undefined;
+                        excerpt?: string | undefined;
+                    };
+                    about?: string | undefined;
+                }>;
+                related?: Record<string, string | string[]> | undefined;
+                identity?: Record<string, string> | undefined;
+            } | null;
+            exampleNote: string;
+        };
+        limits: {
+            maxEvidenceItems: number;
+            maxPassages: number;
+            facts: {
+                maxExcerptCharacters: 2000;
+                maxExcerptsPerQuestion: 3;
+                maxFactsBytes: 524288;
+                maxQuestions: 64;
+            };
+        };
+        purpose?: {
+            text: string;
+            source: {
+                sourceId: string;
+                revision: string;
+                locator: string;
+                contentDigest: string;
+            };
+            parts: {
+                locator: string;
+                text: string;
+            }[];
+        } | undefined;
+        useWhen?: {
+            text: string;
+            source: {
+                sourceId: string;
+                revision: string;
+                locator: string;
+                contentDigest: string;
+            };
+            parts: {
+                locator: string;
+                text: string;
+            }[];
+        }[] | undefined;
+        notFor?: {
+            text: string;
+            source: {
+                sourceId: string;
+                revision: string;
+                locator: string;
+                contentDigest: string;
+            };
+            parts: {
+                locator: string;
+                text: string;
+            }[];
+        }[] | undefined;
+        owner?: {
+            text: string;
+            source: {
+                sourceId: string;
+                revision: string;
+                locator: string;
+                contentDigest: string;
+            };
+            parts: {
+                locator: string;
+                text: string;
+            }[];
+        } | undefined;
+        subject?: {
+            type: string;
+            definition: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            };
+            match: "exact" | "case-insensitive";
+            related: {
+                identifier: string;
+                example: string;
+                match: "exact" | "case-insensitive";
+                relationship: string;
+                meaning: {
+                    text: string;
+                    source: {
+                        sourceId: string;
+                        revision: string;
+                        locator: string;
+                        contentDigest: string;
+                    };
+                    parts: {
+                        locator: string;
+                        text: string;
+                    }[];
+                };
+                cardinality: "one" | "many";
+                required: boolean;
+                subject: string;
+                definition: {
+                    text: string;
+                    source: {
+                        sourceId: string;
+                        revision: string;
+                        locator: string;
+                        contentDigest: string;
+                    };
+                    parts: {
+                        locator: string;
+                        text: string;
+                    }[];
+                };
+            }[];
+            send: string;
+            identifier?: string | undefined;
+            example?: string | undefined;
+        } | undefined;
+        identity?: {
+            mode: "provided" | "fields" | "content" | "issued";
+            send: string;
+            fields?: {
+                identifier: string;
+                example: string;
+                match: "exact" | "case-insensitive";
+                name: string;
+            }[] | undefined;
+            question?: string | undefined;
+        } | undefined;
+        escalations?: {
+            routes: {
+                id: string;
+                quote: {
+                    text: string;
+                    source: {
+                        sourceId: string;
+                        revision: string;
+                        locator: string;
+                        contentDigest: string;
+                    };
+                    parts: {
+                        locator: string;
+                        text: string;
+                    }[];
+                };
+            }[];
+            unresolved: string | null;
+            attemptLimit: string | null;
+            rule: string;
+        } | undefined;
+        whenUnresolved?: {
+            text: string;
+            source: {
+                sourceId: string;
+                revision: string;
+                locator: string;
+                contentDigest: string;
+            };
+            parts: {
+                locator: string;
+                text: string;
+            }[];
+        } | null | undefined;
+        attempts?: {
+            max: number;
+            withProgress: number;
+            rule: string;
+        } | undefined;
+    }>;
     resolveJob: (id: string, value: unknown) => Promise<FelsparJobResult>;
     executeJob: (id: string, value: unknown) => Promise<{
         status: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@felspar/sdk",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Client and action gate for Felspar, the shared decision system for enterprise agents.",
   "license": "Apache-2.0",
   "homepage": "https://docs.felspar.ai",
@@ -50,13 +50,8 @@
     },
     "./package.json": "./package.json"
   },
-  "bin": {
-    "felspar-sdk": "bin/felspar-sdk.mjs"
-  },
   "files": [
     "dist",
-    "bin",
-    "skills/felspar/SKILL.md",
     "README.md",
     "LICENSE"
   ],

package/bin/felspar-sdk.mjs

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// The package's command line: `npx @felspar/sdk skill [dir] [--force]`.
-import { main } from "./skill.mjs";
-
-try {
-  console.log(`Wrote ${main(process.argv.slice(2))}`);
-} catch (error) {
-  console.error(error.message);
-  process.exitCode = 1;
-}

package/bin/skill.mjs

@@ -1,33 +0,0 @@
-// `npx @felspar/sdk skill [dir] [--force]` copies Felspar's agent skill, the
-// method for running any Felspar job, to <dir>/skills/felspar/SKILL.md. The
-// directory defaults to agent, where an Eve agent keeps its skills.
-import { constants, copyFileSync, mkdirSync } from "node:fs";
-import path from "node:path";
-
-export const skillSource = path.join(import.meta.dirname, "../skills/felspar/SKILL.md");
-const usage = "usage: npx @felspar/sdk skill [dir] [--force]";
-
-// Copies the skill and returns where it went. Without force an existing file
-// is kept: COPYFILE_EXCL fails on any existing path, a dangling link included.
-export function installSkill(directory = "agent", { force = false } = {}) {
-  const target = path.join(directory, "skills", "felspar", "SKILL.md");
-  const mode = force ? 0 : constants.COPYFILE_EXCL;
-  mkdirSync(path.dirname(target), { recursive: true });
-  try {
-    copyFileSync(skillSource, target, mode);
-  } catch (error) {
-    throw error.code === "EEXIST"
-      ? new Error(`${target} exists; pass --force to replace it`, { cause: error })
-      : error;
-  }
-  return target;
-}
-
-export function main(argv) {
-  const force = argv.includes("--force");
-  const [command, directory, ...rest] = argv.filter((argument) => argument !== "--force");
-  if (command !== "skill" || rest.length > 0 || directory?.startsWith("-")) {
-    throw new Error(usage);
-  }
-  return installSkill(directory, { force });
-}