agentfootprint 6.44.0 → 7.0.0

package/dist/core/agent/stages/pickEntry.js.map

@@ -1 +1 @@
-{"version":3,"file":"pickEntry.js","sourceRoot":"","sources":["../../../../src/core/agent/stages/pickEntry.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH,6CAAwC;AAMxC,SAAgB,kBAAkB,CAChC,YAAoF;IAEpF,OAAO,KAAK,EAAE,KAA6B,EAAiB,EAAE;QAC5D,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,GAAG,GAAqB;YAC5B,SAAS,EAAG,KAAK,CAAC,SAAgC,IAAI,CAAC;YACvD,WAAW,EAAG,KAAK,CAAC,WAAkC,IAAI,EAAE;YAC5D,OAAO,EAAG,KAAK,CAAC,OAAmD,IAAI,EAAE;YACzE,qBAAqB,EAAG,KAAK,CAAC,qBAAuD,IAAI,EAAE;SAC5F,CAAC;QAEF,IAAI,OAAqB,CAAC;QAC1B,IAAI,CAAC;YACH,OAAO,GAAG,MAAM,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAChD,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,qEAAqE;YACrE,oCAAoC;YACpC,IAAI,IAAA,uBAAS,GAAE,EAAE,CAAC;gBAChB,sCAAsC;gBACtC,OAAO,CAAC,IAAI,CACV,0FAA0F;oBACxF,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CACxD,CAAC;YACJ,CAAC;YACD,OAAO;QACT,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACjC,KAAK,CAAC,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;QACxC,CAAC;QACD,yEAAyE;QACzE,KAAK,CAAC,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IACrC,CAAC,CAAC;AACJ,CAAC;AAlCD,gDAkCC"}
+{"version":3,"file":"pickEntry.js","sourceRoot":"","sources":["../../../../src/core/agent/stages/pickEntry.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAEH,6CAAwC;AAMxC,SAAgB,kBAAkB,CAChC,YAAoF;IAEpF,OAAO,KAAK,EAAE,KAA6B,EAAiB,EAAE;QAC5D,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,GAAG,GAAqB;YAC5B,SAAS,EAAG,KAAK,CAAC,SAAgC,IAAI,CAAC;YACvD,WAAW,EAAG,KAAK,CAAC,WAAkC,IAAI,EAAE;YAC5D,OAAO,EAAG,KAAK,CAAC,OAAmD,IAAI,EAAE;YACzE,qBAAqB,EAAG,KAAK,CAAC,qBAAuD,IAAI,EAAE;SAC5F,CAAC;QAEF,IAAI,OAAqB,CAAC;QAC1B,IAAI,CAAC;YACH,OAAO,GAAG,MAAM,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAChD,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,qEAAqE;YACrE,oCAAoC;YACpC,IAAI,IAAA,uBAAS,GAAE,EAAE,CAAC;gBAChB,sCAAsC;gBACtC,OAAO,CAAC,IAAI,CACV,0FAA0F;oBACxF,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CACxD,CAAC;YACJ,CAAC;YACD,OAAO;QACT,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACjC,KAAK,CAAC,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;QACxC,CAAC;QACD,kFAAkF;QAClF,6EAA6E;QAC7E,KAAK,CAAC,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;QACnC,KAAK,CAAC,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IACrC,CAAC,CAAC;AACJ,CAAC;AApCD,gDAoCC"}

package/dist/debug/finders.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * agentfootprint/debug/finders — context-error finder strategies.
+ *
+ * Collapsed home for what was the 3-level-deep
+ * `agentfootprint/observability/contextError/finders` path. Same
+ * tree-shakeable, re-export-only barrel — one finder = one file = one
+ * named export — now under the Debug category where it belongs.
+ *
+ * The old `agentfootprint/observability/contextError/finders` path is kept
+ * (deprecated) for one transition version.
+ */
+__exportStar(require("../observability/contextError/finders/index.js"), exports);
+//# sourceMappingURL=finders.js.map

package/dist/debug/finders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"finders.js","sourceRoot":"","sources":["../../src/debug/finders.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;;;;;;GAUG;AACH,iFAA+D"}

package/dist/debug.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * agentfootprint/debug — diagnosis tools for a BROKEN run.
+ *
+ * Where `agentfootprint/observe` watches a HEALTHY run (recorders), this
+ * subpath is the autopsy kit for a wrong answer. Split out of `observe` in
+ * the surface cleanup — same code, dedicated home, so the import path now
+ * matches the Debug docs category. The honesty discipline is unchanged:
+ * scores/weights are embedding-geometry PROXIES; ablation verdicts are the
+ * ONLY causal claims; slice completeness is bounded by tracking — and says so.
+ *
+ * Four libraries:
+ *   • influence-core   — embedding-based scoring (proxy, never causal)
+ *   • trace-toolpack   — traceToolpack + traceDebugAgent + `.selfExplain()`
+ *   • context-bisect   — localizeContextBug + ablation/restoration probes
+ *   • tool-lint        — build-time tool-catalog confusability lint
+ *
+ * For backward compatibility these are ALSO re-exported (deprecated) from
+ * `agentfootprint/observe` for one transition version.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.llmCallIdsFromEvents = exports.formatContextBugReport = exports.findDroppedContext = exports.defaultSuspectClassifier = exports.defaultOutcomeComparator = exports.CONTEXT_BISECT_DEFAULTS = exports.findLoopHeads = exports.classifySuspect = exports.DEFAULT_RECENCY_DECAY = exports.buildWriterFrameIndex = exports.walkTrajectory = exports.walkToRoot = exports.shortlistEarlyCulprits = exports.bucketByAnchors = exports.bisectCulprits = exports.assignCostVerdicts = exports.assembleTrajectory = exports.applyAblations = exports.ablationForSuspect = exports.traceDebugAgent = exports.SelfExplainBinding = exports.buildSelfExplainToolProvider = exports.buildSelfExplainSkill = exports.traceToolpack = exports.TOOLPACK_HARD_CAPS = exports.NO_COMPLETED_RUN_MESSAGE = exports.lazyTraceToolpack = exports.callTraceTool = exports.structuralProximity = exports.scoreMargin = exports.scoreInfluence = exports.scoreContrastiveInfluence = exports.ratioStrategy = exports.rankingConfidence = exports.persistence = exports.pairwiseSimilarity = exports.marginStrategy = exports.finalAnswerSimilarity = exports.embeddingCache = exports.EmbeddingCache = exports.DEFAULT_SHORTLIST_BAND = exports.DEFAULT_PERSISTENCE_THRESHOLD = exports.DEFAULT_MARGIN_THRESHOLD = exports.DEFAULT_INFLUENCE_WEIGHTS = exports.DEFAULT_CLEAR_WINNER_RATIO = exports.DEFAULT_CLEAR_WINNER_MARGIN = exports.contentHash = exports.compositeScore = exports.averageRelevancy = exports.adaptWeights = void 0;
+exports.saysWhatNotWhenRule = exports.runToolLintCli = exports.optionalParamRule = exports.MOCK_EMBEDDER_CALIBRATION = exports.formatToolCatalogReport = exports.enumInProseRule = exports.differentiationHint = exports.descriptionRule = exports.defaultStructuralRules = exports.DEFAULT_WHEN_CUES = exports.DEFAULT_WATCH_BAND = exports.DEFAULT_OMISSION_CUES = exports.DEFAULT_CONFUSABILITY_THRESHOLD = exports.confusabilityText = exports.coerceCatalog = exports.catalogFromTools = exports.analyzeToolCatalog = exports.toBacktrackTrace = exports.verdictFor = exports.suspectLabel = exports.stepOutputText = exports.runRestorationProbe = exports.runAblationProbe = exports.probeFlipped = exports.localizeContextBug = exports.llmEdgeWeigher = void 0;
+// influence-core — the ONE embedding-based scoring engine (RFC-002/003
+// block D6). Not a recorder: pure, embedder-injected scoring functions
+// + the shared bounded embedding cache. Honest claim: every score is an
+// embedding-geometry PROXY — semantic alignment, never model internals,
+// never causal attribution.
+var index_js_1 = require("./lib/influence-core/index.js");
+Object.defineProperty(exports, "adaptWeights", { enumerable: true, get: function () { return index_js_1.adaptWeights; } });
+Object.defineProperty(exports, "averageRelevancy", { enumerable: true, get: function () { return index_js_1.averageRelevancy; } });
+Object.defineProperty(exports, "compositeScore", { enumerable: true, get: function () { return index_js_1.compositeScore; } });
+Object.defineProperty(exports, "contentHash", { enumerable: true, get: function () { return index_js_1.contentHash; } });
+Object.defineProperty(exports, "DEFAULT_CLEAR_WINNER_MARGIN", { enumerable: true, get: function () { return index_js_1.DEFAULT_CLEAR_WINNER_MARGIN; } });
+Object.defineProperty(exports, "DEFAULT_CLEAR_WINNER_RATIO", { enumerable: true, get: function () { return index_js_1.DEFAULT_CLEAR_WINNER_RATIO; } });
+Object.defineProperty(exports, "DEFAULT_INFLUENCE_WEIGHTS", { enumerable: true, get: function () { return index_js_1.DEFAULT_INFLUENCE_WEIGHTS; } });
+Object.defineProperty(exports, "DEFAULT_MARGIN_THRESHOLD", { enumerable: true, get: function () { return index_js_1.DEFAULT_MARGIN_THRESHOLD; } });
+Object.defineProperty(exports, "DEFAULT_PERSISTENCE_THRESHOLD", { enumerable: true, get: function () { return index_js_1.DEFAULT_PERSISTENCE_THRESHOLD; } });
+Object.defineProperty(exports, "DEFAULT_SHORTLIST_BAND", { enumerable: true, get: function () { return index_js_1.DEFAULT_SHORTLIST_BAND; } });
+Object.defineProperty(exports, "EmbeddingCache", { enumerable: true, get: function () { return index_js_1.EmbeddingCache; } });
+Object.defineProperty(exports, "embeddingCache", { enumerable: true, get: function () { return index_js_1.embeddingCache; } });
+Object.defineProperty(exports, "finalAnswerSimilarity", { enumerable: true, get: function () { return index_js_1.finalAnswerSimilarity; } });
+Object.defineProperty(exports, "marginStrategy", { enumerable: true, get: function () { return index_js_1.marginStrategy; } });
+Object.defineProperty(exports, "pairwiseSimilarity", { enumerable: true, get: function () { return index_js_1.pairwiseSimilarity; } });
+Object.defineProperty(exports, "persistence", { enumerable: true, get: function () { return index_js_1.persistence; } });
+Object.defineProperty(exports, "rankingConfidence", { enumerable: true, get: function () { return index_js_1.rankingConfidence; } });
+Object.defineProperty(exports, "ratioStrategy", { enumerable: true, get: function () { return index_js_1.ratioStrategy; } });
+Object.defineProperty(exports, "scoreContrastiveInfluence", { enumerable: true, get: function () { return index_js_1.scoreContrastiveInfluence; } });
+Object.defineProperty(exports, "scoreInfluence", { enumerable: true, get: function () { return index_js_1.scoreInfluence; } });
+Object.defineProperty(exports, "scoreMargin", { enumerable: true, get: function () { return index_js_1.scoreMargin; } });
+Object.defineProperty(exports, "structuralProximity", { enumerable: true, get: function () { return index_js_1.structuralProximity; } });
+// Introspection toolpack (RFC-003 Part C) — footprintjs trace evidence
+// exposed as TOOLS a debugging LLM calls over a COMPLETED run's artifacts.
+// Bounded, honest (⚠ markers), redaction-respecting, id-navigable.
+var index_js_2 = require("./lib/trace-toolpack/index.js");
+Object.defineProperty(exports, "callTraceTool", { enumerable: true, get: function () { return index_js_2.callTraceTool; } });
+Object.defineProperty(exports, "lazyTraceToolpack", { enumerable: true, get: function () { return index_js_2.lazyTraceToolpack; } });
+Object.defineProperty(exports, "NO_COMPLETED_RUN_MESSAGE", { enumerable: true, get: function () { return index_js_2.NO_COMPLETED_RUN_MESSAGE; } });
+Object.defineProperty(exports, "TOOLPACK_HARD_CAPS", { enumerable: true, get: function () { return index_js_2.TOOLPACK_HARD_CAPS; } });
+Object.defineProperty(exports, "traceToolpack", { enumerable: true, get: function () { return index_js_2.traceToolpack; } });
+// The two conversational doors over the toolpack: a DEDICATED debugger
+// agent (separate session, any provider — cheap models welcome), and the
+// in-conversation `.selfExplain()` builder option's types. Same evidence,
+// same honesty discipline as the UI doors (BacktrackView / Lens).
+var index_js_3 = require("./lib/trace-toolpack/index.js");
+Object.defineProperty(exports, "buildSelfExplainSkill", { enumerable: true, get: function () { return index_js_3.buildSelfExplainSkill; } });
+Object.defineProperty(exports, "buildSelfExplainToolProvider", { enumerable: true, get: function () { return index_js_3.buildSelfExplainToolProvider; } });
+Object.defineProperty(exports, "SelfExplainBinding", { enumerable: true, get: function () { return index_js_3.SelfExplainBinding; } });
+Object.defineProperty(exports, "traceDebugAgent", { enumerable: true, get: function () { return index_js_3.traceDebugAgent; } });
+// Contextual-bug localizer (RFC-003 Part B, D7–D9) — "git bisect for
+// context". Assembly: footprintjs causal DAG (control edges + honesty
+// markers + EdgeWeigher) × influence-core scoring (D6) × consumer-run
+// counterfactual ablation. §B2 claim tiers: scores/weights are
+// embedding-geometry PROXIES; ablation verdicts are the ONLY causal
+// claims; slice completeness is bounded by tracking — and says so.
+var index_js_4 = require("./lib/context-bisect/index.js");
+Object.defineProperty(exports, "ablationForSuspect", { enumerable: true, get: function () { return index_js_4.ablationForSuspect; } });
+Object.defineProperty(exports, "applyAblations", { enumerable: true, get: function () { return index_js_4.applyAblations; } });
+Object.defineProperty(exports, "assembleTrajectory", { enumerable: true, get: function () { return index_js_4.assembleTrajectory; } });
+Object.defineProperty(exports, "assignCostVerdicts", { enumerable: true, get: function () { return index_js_4.assignCostVerdicts; } });
+Object.defineProperty(exports, "bisectCulprits", { enumerable: true, get: function () { return index_js_4.bisectCulprits; } });
+Object.defineProperty(exports, "bucketByAnchors", { enumerable: true, get: function () { return index_js_4.bucketByAnchors; } });
+Object.defineProperty(exports, "shortlistEarlyCulprits", { enumerable: true, get: function () { return index_js_4.shortlistEarlyCulprits; } });
+Object.defineProperty(exports, "walkToRoot", { enumerable: true, get: function () { return index_js_4.walkToRoot; } });
+Object.defineProperty(exports, "walkTrajectory", { enumerable: true, get: function () { return index_js_4.walkTrajectory; } });
+Object.defineProperty(exports, "buildWriterFrameIndex", { enumerable: true, get: function () { return index_js_4.buildWriterFrameIndex; } });
+Object.defineProperty(exports, "DEFAULT_RECENCY_DECAY", { enumerable: true, get: function () { return index_js_4.DEFAULT_RECENCY_DECAY; } });
+Object.defineProperty(exports, "classifySuspect", { enumerable: true, get: function () { return index_js_4.classifySuspect; } });
+Object.defineProperty(exports, "findLoopHeads", { enumerable: true, get: function () { return index_js_4.findLoopHeads; } });
+Object.defineProperty(exports, "CONTEXT_BISECT_DEFAULTS", { enumerable: true, get: function () { return index_js_4.CONTEXT_BISECT_DEFAULTS; } });
+Object.defineProperty(exports, "defaultOutcomeComparator", { enumerable: true, get: function () { return index_js_4.defaultOutcomeComparator; } });
+Object.defineProperty(exports, "defaultSuspectClassifier", { enumerable: true, get: function () { return index_js_4.defaultSuspectClassifier; } });
+Object.defineProperty(exports, "findDroppedContext", { enumerable: true, get: function () { return index_js_4.findDroppedContext; } });
+Object.defineProperty(exports, "formatContextBugReport", { enumerable: true, get: function () { return index_js_4.formatContextBugReport; } });
+Object.defineProperty(exports, "llmCallIdsFromEvents", { enumerable: true, get: function () { return index_js_4.llmCallIdsFromEvents; } });
+Object.defineProperty(exports, "llmEdgeWeigher", { enumerable: true, get: function () { return index_js_4.llmEdgeWeigher; } });
+Object.defineProperty(exports, "localizeContextBug", { enumerable: true, get: function () { return index_js_4.localizeContextBug; } });
+Object.defineProperty(exports, "probeFlipped", { enumerable: true, get: function () { return index_js_4.probeFlipped; } });
+Object.defineProperty(exports, "runAblationProbe", { enumerable: true, get: function () { return index_js_4.runAblationProbe; } });
+Object.defineProperty(exports, "runRestorationProbe", { enumerable: true, get: function () { return index_js_4.runRestorationProbe; } });
+Object.defineProperty(exports, "stepOutputText", { enumerable: true, get: function () { return index_js_4.stepOutputText; } });
+Object.defineProperty(exports, "suspectLabel", { enumerable: true, get: function () { return index_js_4.suspectLabel; } });
+Object.defineProperty(exports, "verdictFor", { enumerable: true, get: function () { return index_js_4.verdictFor; } });
+// BacktrackTrace serializer — feeds agentThinkingUI's <BacktrackView>
+// (the "why?" board) straight off a localizer report. Pure mapping, no
+// UI dependency; the interfaces mirror agentthinkingui's contract.
+var index_js_5 = require("./lib/context-bisect/index.js");
+Object.defineProperty(exports, "toBacktrackTrace", { enumerable: true, get: function () { return index_js_5.toBacktrackTrace; } });
+// Tool-catalog confusability lint (RFC-002 tier 1, C1–C3) — build-time,
+// CI-gateable, framework-agnostic: plain { name, description?, inputSchema? }
+// tools in (OpenAI/Anthropic/MCP lists coerce via coerceCatalog; the
+// library's Tool[] via catalogFromTools), a report with a gateable `ok`
+// out. Pluggable structural rule pack; thresholds + embedder consumer-
+// injected with our defaults. Bin: `agentfootprint-lint-tools`.
+// Front door: docs/guides/tool-catalog-lint.md.
+var index_js_6 = require("./lib/tool-lint/index.js");
+Object.defineProperty(exports, "analyzeToolCatalog", { enumerable: true, get: function () { return index_js_6.analyzeToolCatalog; } });
+Object.defineProperty(exports, "catalogFromTools", { enumerable: true, get: function () { return index_js_6.catalogFromTools; } });
+Object.defineProperty(exports, "coerceCatalog", { enumerable: true, get: function () { return index_js_6.coerceCatalog; } });
+Object.defineProperty(exports, "confusabilityText", { enumerable: true, get: function () { return index_js_6.confusabilityText; } });
+Object.defineProperty(exports, "DEFAULT_CONFUSABILITY_THRESHOLD", { enumerable: true, get: function () { return index_js_6.DEFAULT_CONFUSABILITY_THRESHOLD; } });
+Object.defineProperty(exports, "DEFAULT_OMISSION_CUES", { enumerable: true, get: function () { return index_js_6.DEFAULT_OMISSION_CUES; } });
+Object.defineProperty(exports, "DEFAULT_WATCH_BAND", { enumerable: true, get: function () { return index_js_6.DEFAULT_WATCH_BAND; } });
+Object.defineProperty(exports, "DEFAULT_WHEN_CUES", { enumerable: true, get: function () { return index_js_6.DEFAULT_WHEN_CUES; } });
+Object.defineProperty(exports, "defaultStructuralRules", { enumerable: true, get: function () { return index_js_6.defaultStructuralRules; } });
+Object.defineProperty(exports, "descriptionRule", { enumerable: true, get: function () { return index_js_6.descriptionRule; } });
+Object.defineProperty(exports, "differentiationHint", { enumerable: true, get: function () { return index_js_6.differentiationHint; } });
+Object.defineProperty(exports, "enumInProseRule", { enumerable: true, get: function () { return index_js_6.enumInProseRule; } });
+Object.defineProperty(exports, "formatToolCatalogReport", { enumerable: true, get: function () { return index_js_6.formatToolCatalogReport; } });
+Object.defineProperty(exports, "MOCK_EMBEDDER_CALIBRATION", { enumerable: true, get: function () { return index_js_6.MOCK_EMBEDDER_CALIBRATION; } });
+Object.defineProperty(exports, "optionalParamRule", { enumerable: true, get: function () { return index_js_6.optionalParamRule; } });
+Object.defineProperty(exports, "runToolLintCli", { enumerable: true, get: function () { return index_js_6.runToolLintCli; } });
+Object.defineProperty(exports, "saysWhatNotWhenRule", { enumerable: true, get: function () { return index_js_6.saysWhatNotWhenRule; } });
+//# sourceMappingURL=debug.js.map

package/dist/debug.js.map

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

package/dist/esm/adapters/identity/agentcore.d.ts

@@ -0,0 +1,100 @@
+/**
+ * agentCoreIdentity — AWS Bedrock AgentCore Identity adapter (peer-dep
+ * `@aws-sdk/client-bedrock-agentcore`).
+ *
+ *   import { agentCoreIdentity } from 'agentfootprint/identity';
+ *   const credentials = agentCoreIdentity({ region: 'us-east-1' });
+ *
+ * Maps the {@link CredentialProvider} port onto AgentCore Identity's
+ * `GetResourceOauth2Token` (the SDK's `@requires_access_token` underneath):
+ *   - request.mode 'machine' → `M2M`; 'user' → `USER_FEDERATION`
+ *   - request.service        → the configured OAuth2 credential-provider name
+ *   - request.identity       → (per-request workload identity scoping; see below)
+ *   - a returned access token → `{ status: 'issued', credential: bearer(token) }`
+ *   - a returned auth URL     → `{ status: 'authorization-required' }` (3LO consent)
+ *
+ * The token vault + refresh-token handling live in AgentCore, so repeat calls
+ * usually return a token directly (no consent round-trip).
+ *
+ * **Per-request identity forwarding (workload identity scoping).**
+ * `GetResourceOauth2Token` carries NO user/tenant field — in AgentCore the
+ * user identity is bound EARLIER, at workload-token acquisition:
+ * `GetWorkloadAccessTokenForUserId(workloadName, userId)` returns a workload
+ * access token scoped to that user, and AgentCore keys its token vault + 3LO
+ * grants per (workload, user). So this adapter forwards `req.identity` (the
+ * `runIdentity` that the agent threads through `getCredential`) by resolving a
+ * per-user workload token first, then vending with it. Engages only when ALL of:
+ *   - `req.mode === 'user'` (USER_FEDERATION — M2M is the workload's own identity),
+ *   - a userId derives from `req.identity` (default `identity.principal`;
+ *     override via `userIdFor`), and
+ *   - `options.workloadName` is configured (the opt-in).
+ * Otherwise the static `options.workloadIdentityToken` flows exactly as before.
+ * `tenant` has no native AgentCore field and is NOT forwarded by default —
+ * tenant isolation derives from the workload identity itself (per-tenant
+ * workloads), or encode it via `userIdFor` (e.g. `${tenant}:${principal}`).
+ *
+ * Pattern: Adapter (GoF) + lazy peer-dep load — the AWS SDK is required only when
+ * `getCredential` first runs (or never, if you inject `_client`). NOTE: confirm
+ * the SDK command/field names against your installed
+ * `@aws-sdk/client-bedrock-agentcore` version — this adapter targets the
+ * `GetResourceOauth2Token` shape and is structured so the request→result mapping
+ * is unit-tested via the `_client` seam independent of the SDK.
+ */
+import type { CredentialProvider } from '../../identity/types.js';
+/** Raw result shape we consume from the AgentCore identity client. */
+export interface AgentCoreOauthResponse {
+    readonly accessToken?: string;
+    readonly authorizationUrl?: string;
+    readonly sessionId?: string;
+    /** Unix seconds. */
+    readonly expiresAt?: number;
+}
+/** The minimal client surface the adapter calls — wraps `GetResourceOauth2Token`
+ *  and (for per-user workload scoping) `GetWorkloadAccessTokenForUserId`.
+ *  The real AWS SDK client is adapted to this; tests inject a fake via `_client`. */
+export interface AgentCoreIdentityClientLike {
+    getResourceOauth2Token(input: {
+        readonly resourceCredentialProviderName: string;
+        readonly scopes: readonly string[];
+        readonly oauth2Flow: 'M2M' | 'USER_FEDERATION';
+        readonly forceAuthentication: boolean;
+        readonly workloadIdentityToken?: string;
+    }): Promise<AgentCoreOauthResponse>;
+    /** Optional — required only when `workloadName` is configured. Exchanges
+     *  (workloadName, userId) for a USER-SCOPED workload access token; AgentCore
+     *  keys its token vault + 3LO grants per (workload, user). */
+    getWorkloadAccessTokenForUserId?(input: {
+        readonly workloadName: string;
+        readonly userId: string;
+    }): Promise<{
+        readonly workloadAccessToken?: string;
+    }>;
+}
+export interface AgentCoreIdentityOptions {
+    readonly region?: string;
+    /** The agent's workload access token (AgentCore Runtime injects one in-container;
+     *  supply it explicitly when running elsewhere). Used as-is unless a per-user
+     *  workload token is resolved (see `workloadName`). */
+    readonly workloadIdentityToken?: string;
+    /** The AgentCore workload identity name — the OPT-IN for per-request identity
+     *  scoping. When set, `mode: 'user'` requests carrying `req.identity` resolve a
+     *  per-user workload access token via `GetWorkloadAccessTokenForUserId(workloadName,
+     *  userId)` before vending, so AgentCore's token vault + 3LO grants are keyed per
+     *  (workload, user) instead of per workload. Omit → today's static-token behavior. */
+    readonly workloadName?: string;
+    /** Map `req.identity` → the AgentCore `userId`. Default: `identity.principal`.
+     *  `tenant` has no native AgentCore field — encode it here if you need
+     *  tenant-scoped vault entries (e.g. ``({ tenant, principal }) =>
+     *  tenant && principal ? `${tenant}:${principal}` : principal``). Return
+     *  `undefined` to skip per-user scoping for that request. */
+    readonly userIdFor?: (identity: {
+        readonly principal?: string;
+        readonly tenant?: string;
+    }) => string | undefined;
+    /** Stable provider id (default 'agentcore-identity'). */
+    readonly id?: string;
+    /** Test seam — inject a client implementing {@link AgentCoreIdentityClientLike}. */
+    readonly _client?: AgentCoreIdentityClientLike;
+}
+/** Build a {@link CredentialProvider} backed by AWS Bedrock AgentCore Identity. */
+export declare function agentCoreIdentity(options?: AgentCoreIdentityOptions): CredentialProvider;

package/dist/esm/adapters/llm/AnthropicProvider.d.ts

@@ -0,0 +1,130 @@
+/**
+ * AnthropicProvider — wraps `@anthropic-ai/sdk` as an `LLMProvider`.
+ *
+ * Pattern: Adapter (GoF) + Ports-and-Adapters (Cockburn 2005).
+ * Role:    Outer ring — translates `LLMRequest`/`LLMResponse` to/from
+ *          Anthropic's Messages API. Knows nothing about agents,
+ *          recorders, or compositions.
+ * Emits:   N/A — providers don't emit; recorders observe via Agent.
+ *
+ * ─── Limitations ────────────────────────────────────────────────────
+ *
+ * • Multi-modal content (images, video) NOT supported  — the framework's
+ *   `LLMMessage.content` is `string`. The adapter accepts text-only.
+ *   May extend in a future release the message shape; this provider will be updated
+ *   in lockstep.
+ * • `responseFormat` (JSON-Schema-coerced output) NOT exposed
+ *   — consumers can pass schema instructions via `systemPrompt`.
+ */
+import type { LLMChunk, LLMProvider, LLMRequest, LLMResponse } from '../types.js';
+interface AnthropicClient {
+    messages: {
+        create(params: AnthropicCreateParams): Promise<AnthropicMessage>;
+        stream(params: AnthropicCreateParams): AnthropicStream;
+    };
+}
+interface AnthropicCreateParams {
+    model: string;
+    max_tokens: number;
+    messages: AnthropicMessageParam[];
+    system?: string;
+    tools?: AnthropicTool[];
+    temperature?: number;
+    stop_sequences?: string[];
+    thinking?: {
+        type: 'enabled';
+        budget_tokens: number;
+    };
+}
+interface AnthropicMessageParam {
+    role: 'user' | 'assistant';
+    content: string | AnthropicContentBlock[];
+}
+type AnthropicContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+} | {
+    type: 'thinking';
+    thinking: string;
+    signature?: string;
+} | {
+    type: 'redacted_thinking';
+    signature?: string;
+};
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}
+interface AnthropicMessage {
+    id: string;
+    model: string;
+    role: 'assistant';
+    content: AnthropicContentBlock[];
+    stop_reason: 'end_turn' | 'tool_use' | 'max_tokens' | string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+interface AnthropicStream {
+    finalMessage(): Promise<AnthropicMessage>;
+    [Symbol.asyncIterator](): AsyncIterator<AnthropicStreamEvent>;
+}
+interface AnthropicStreamEvent {
+    type: string;
+    delta?: {
+        type: string;
+        text?: string;
+    };
+}
+export interface AnthropicProviderOptions {
+    /** API key. Defaults to `ANTHROPIC_API_KEY` env var. */
+    readonly apiKey?: string;
+    /**
+     * Default model used when `LLMRequest.model` is `'anthropic'` (the
+     * shorthand). When the request specifies a full model id, that wins.
+     */
+    readonly defaultModel?: string;
+    /** Default max tokens when the request doesn't set it. Default 4096. */
+    readonly defaultMaxTokens?: number;
+    /** @internal Pre-built client for testing. Skips SDK import. */
+    readonly _client?: AnthropicClient;
+}
+/**
+ * Build an `LLMProvider` backed by Anthropic's Messages API.
+ *
+ * @example
+ *   import { Agent } from 'agentfootprint';
+ *   import { anthropic } from 'agentfootprint/llm-providers';
+ *
+ *   const agent = Agent.create({
+ *     provider: anthropic({ defaultModel: 'claude-sonnet-4-5-20250929' }),
+ *     model: 'anthropic',
+ *   })
+ *     .tool(weatherTool)
+ *     .build();
+ */
+export declare function anthropic(options?: AnthropicProviderOptions): LLMProvider;
+/**
+ * Class form for consumers who prefer `new AnthropicProvider(...)` over
+ * the `anthropic(...)` factory. Identical behavior; trivial wrapper.
+ */
+export declare class AnthropicProvider implements LLMProvider {
+    readonly name = "anthropic";
+    private readonly inner;
+    constructor(options?: AnthropicProviderOptions);
+    complete(req: LLMRequest): Promise<LLMResponse>;
+    stream(req: LLMRequest): AsyncIterable<LLMChunk>;
+}
+export {};

package/dist/esm/adapters/llm/BedrockProvider.d.ts

@@ -0,0 +1,100 @@
+/**
+ * BedrockProvider — wraps AWS Bedrock's Converse API as an `LLMProvider`.
+ *
+ * Pattern: Adapter (GoF) + Ports-and-Adapters (Cockburn 2005).
+ * Role:    Outer ring — translates `LLMRequest`/`LLMResponse` to/from
+ *          AWS Bedrock's model-agnostic Converse / ConverseStream APIs.
+ *          Works with ANY Bedrock-hosted model (Claude, Llama, Mistral,
+ *          Titan, Mixtral, ...) without format-specific code.
+ * Emits:   N/A.
+ *
+ * Requires: `npm install @aws-sdk/client-bedrock-runtime`
+ *
+ * The Converse API is model-agnostic — one adapter covers every
+ * Bedrock-hosted model (Claude, Llama, Mistral, Titan, Mixtral, ...).
+ *
+ * ─── Limitations ────────────────────────────────────────────────────
+ *
+ * • Multi-modal NOT supported  (text content only).
+ * • Guardrail integration NOT exposed yet — pass via the SDK client
+ *   directly if needed.
+ */
+import type { LLMChunk, LLMProvider, LLMRequest, LLMResponse } from '../types.js';
+interface BedrockClient {
+    send(command: unknown): Promise<unknown>;
+}
+interface BedrockConverseCommand {
+    modelId: string;
+    messages: BedrockMessage[];
+    system?: Array<{
+        text: string;
+    }>;
+    toolConfig?: {
+        tools: BedrockTool[];
+    };
+    inferenceConfig?: {
+        maxTokens?: number;
+        temperature?: number;
+        stopSequences?: string[];
+    };
+}
+interface BedrockMessage {
+    role: 'user' | 'assistant';
+    content: BedrockContentBlock[];
+}
+type BedrockContentBlock = {
+    text: string;
+} | {
+    toolUse: {
+        toolUseId: string;
+        name: string;
+        input: Record<string, unknown>;
+    };
+} | {
+    toolResult: {
+        toolUseId: string;
+        content: Array<{
+            text: string;
+        }>;
+        status?: 'success' | 'error';
+    };
+};
+interface BedrockTool {
+    toolSpec: {
+        name: string;
+        description: string;
+        inputSchema: {
+            json: Record<string, unknown>;
+        };
+    };
+}
+export interface BedrockProviderOptions {
+    /** AWS region (e.g., 'us-east-1'). Defaults to AWS SDK auto-detect. */
+    readonly region?: string;
+    /**
+     * Default model id (e.g., `anthropic.claude-sonnet-4-5-20250929-v1:0`).
+     * Used when `LLMRequest.model` is the shorthand `'bedrock'`.
+     */
+    readonly defaultModel?: string;
+    /** Default max tokens when not in the request. Default 4096. */
+    readonly defaultMaxTokens?: number;
+    /** @internal Pre-built client for testing. */
+    readonly _client?: BedrockClient;
+    /**
+     * @internal Test override for the SDK's command constructors. Real
+     * use goes through the dynamic `require('@aws-sdk/client-bedrock-runtime')`.
+     */
+    readonly _commands?: {
+        readonly Converse: new (input: BedrockConverseCommand) => unknown;
+        readonly ConverseStream: new (input: BedrockConverseCommand) => unknown;
+    };
+}
+export declare function bedrock(options?: BedrockProviderOptions): LLMProvider;
+export declare class BedrockProvider implements LLMProvider {
+    readonly name = "bedrock";
+    private readonly inner;
+    constructor(options?: BedrockProviderOptions);
+    complete(req: LLMRequest): Promise<LLMResponse>;
+    stream(req: LLMRequest): AsyncIterable<LLMChunk>;
+}
+export {};

package/dist/esm/adapters/llm/BrowserAnthropicProvider.d.ts

@@ -0,0 +1,41 @@
+/**
+ * BrowserAnthropicProvider — fetch-based Anthropic adapter for browsers.
+ *
+ * Pattern: Adapter (GoF). Zero peer dependencies — uses global `fetch`.
+ * Role:    Outer ring. Same `LLMProvider` contract as `AnthropicProvider`,
+ *          but skips `@anthropic-ai/sdk` (which doesn't bundle cleanly
+ *          for browser). Aimed at playgrounds / prototypes where the
+ *          user supplies their own key.
+ * Emits:   N/A.
+ *
+ * Anthropic requires the `anthropic-dangerous-direct-browser-access: true`
+ * header for direct browser-to-API calls. This is intentional — production
+ * apps should proxy through a backend.
+ *
+ * ─── Limitations ────────────────────────────────────────────────────
+ *
+ * • Multi-modal NOT supported.
+ * • Browser CORS — works because Anthropic explicitly allows the
+ *   dangerous-direct header. Future API changes could require a proxy.
+ */
+import type { LLMChunk, LLMProvider, LLMRequest, LLMResponse } from '../types.js';
+export interface BrowserAnthropicProviderOptions {
+    /** API key. REQUIRED — browser providers don't read env vars. */
+    readonly apiKey: string;
+    /** Default model when `LLMRequest.model` is `'anthropic'`. */
+    readonly defaultModel?: string;
+    /** Default max tokens. Default 4096. */
+    readonly defaultMaxTokens?: number;
+    /** Override the API URL (proxies, edge deployments, mocks). */
+    readonly apiUrl?: string;
+    /** @internal Custom fetch implementation for tests / workers. */
+    readonly _fetch?: typeof fetch;
+}
+export declare function browserAnthropic(options: BrowserAnthropicProviderOptions): LLMProvider;
+export declare class BrowserAnthropicProvider implements LLMProvider {
+    readonly name = "browser-anthropic";
+    private readonly inner;
+    constructor(options: BrowserAnthropicProviderOptions);
+    complete(req: LLMRequest): Promise<LLMResponse>;
+    stream(req: LLMRequest): AsyncIterable<LLMChunk>;
+}