@tangle-network/agent-core 0.10.0 → 0.10.2

package/dist/auth/index.d.ts

@@ -3,7 +3,7 @@ import { C as AuthProvider, D as RefreshableTokenAuth, E as ReadTokenAuth, O as
 /**
  * Result of channel access check.
  */
-interface ChannelAccessResult {
+export interface ChannelAccessResult {
   /** Whether access is allowed */
   allowed: boolean;
   /** Reason for denial (if not allowed) */
@@ -13,12 +13,12 @@ interface ChannelAccessResult {
  * Extract session ID from a session channel pattern.
  * Returns null if not a session channel.
  */
-declare function extractSessionFromChannel(channel: string): string | null;
+export declare function extractSessionFromChannel(channel: string): string | null;
 /**
  * Extract project ID from a project channel pattern.
  * Returns null if not a project channel.
  */
-declare function extractProjectFromChannel(channel: string): string | null;
+export declare function extractProjectFromChannel(channel: string): string | null;
 /**
  * Check if a session-scoped token can access a channel.
  *
@@ -28,7 +28,7 @@ declare function extractProjectFromChannel(channel: string): string | null;
  * - system (always allowed)
  * - Wildcard patterns matching their session
  */
-declare function canSessionTokenAccessChannel(payload: SessionScopedTokenPayload, channel: string): ChannelAccessResult;
+export declare function canSessionTokenAccessChannel(payload: SessionScopedTokenPayload, channel: string): ChannelAccessResult;
 /**
  * Check if a project-scoped token can access a channel.
  *
@@ -38,7 +38,7 @@ declare function canSessionTokenAccessChannel(payload: SessionScopedTokenPayload
  * - agent:* (all agent events within project)
  * - system (always allowed)
  */
-declare function canProjectTokenAccessChannel(payload: ProjectScopedTokenPayload, channel: string): ChannelAccessResult;
+export declare function canProjectTokenAccessChannel(payload: ProjectScopedTokenPayload, channel: string): ChannelAccessResult;
 /**
  * Check if a batch-scoped token can access a channel.
  *
@@ -49,7 +49,7 @@ declare function canProjectTokenAccessChannel(payload: ProjectScopedTokenPayload
  * - system (always allowed)
  * - * (global wildcard - for organization-wide subscriptions)
  */
-declare function canBatchTokenAccessChannel(payload: BatchScopedTokenPayload, channel: string): ChannelAccessResult;
+export declare function canBatchTokenAccessChannel(payload: BatchScopedTokenPayload, channel: string): ChannelAccessResult;
 /**
  * Check if a token can access a channel.
  * Dispatches to scope-specific functions based on token type.
@@ -58,7 +58,7 @@ declare function canBatchTokenAccessChannel(payload: BatchScopedTokenPayload, ch
  * @param channel - The channel to check access for
  * @returns Access result with allowed boolean and optional reason
  */
-declare function canTokenAccessChannel(payload: ReadTokenPayload, channel: string): ChannelAccessResult;
+export declare function canTokenAccessChannel(payload: ReadTokenPayload, channel: string): ChannelAccessResult;
 /**
  * Get the list of allowed channel patterns for a token.
  * Useful for informing clients what they can subscribe to.
@@ -66,7 +66,7 @@ declare function canTokenAccessChannel(payload: ReadTokenPayload, channel: strin
  * @param payload - The token payload
  * @returns Array of allowed channel patterns
  */
-declare function getAllowedChannelPatterns(payload: ReadTokenPayload): string[];
+export declare function getAllowedChannelPatterns(payload: ReadTokenPayload): string[];
 /**
  * Validate channel subscription request.
  * Checks multiple channels and returns aggregated result.
@@ -75,7 +75,7 @@ declare function getAllowedChannelPatterns(payload: ReadTokenPayload): string[];
  * @param channels - Channels to validate
  * @returns Object with allowed channels and denied channels with reasons
  */
-declare function validateChannelSubscription(payload: ReadTokenPayload, channels: string[]): {
+export declare function validateChannelSubscription(payload: ReadTokenPayload, channels: string[]): {
   allowed: string[];
   denied: Array<{
     channel: string;
@@ -89,15 +89,15 @@ declare function validateChannelSubscription(payload: ReadTokenPayload, channels
  * @param prefix - Prefix for the generated string (e.g., "orch_prod_")
  * @param bytes - Number of random bytes (default: 32 = 256 bits)
  */
-declare function generateSecureToken(prefix: string, bytes?: number): string;
+export declare function generateSecureToken(prefix: string, bytes?: number): string;
 /**
  * Generate a product API key.
  */
-declare function generateApiKey(): string;
+export declare function generateApiKey(): string;
 /**
  * Generate a signing secret.
  */
-declare function generateSigningSecret(): string;
+export declare function generateSigningSecret(): string;
 /**
  * Issue a read token (JWT) for WebSocket authentication.
  *
@@ -105,7 +105,7 @@ declare function generateSigningSecret(): string;
  * @param payload - Token payload (without iat/exp, those are added)
  * @param ttlMinutes - Token TTL in minutes
  */
-declare function issueReadToken(signingSecret: string, payload: Omit<ReadTokenPayload, "iat" | "exp" | "typ">, ttlMinutes: number): string;
+export declare function issueReadToken(signingSecret: string, payload: Omit<ReadTokenPayload, "iat" | "exp" | "typ">, ttlMinutes: number): string;
 /**
  * Issue a session-scoped token (JWT) for WebSocket authentication.
  * Grants access to a single session's events.
@@ -114,7 +114,7 @@ declare function issueReadToken(signingSecret: string, payload: Omit<ReadTokenPa
  * @param payload - Token payload with session ID
  * @param ttlMinutes - Token TTL in minutes
  */
-declare function issueSessionScopedToken(signingSecret: string, payload: Omit<SessionScopedTokenPayload, "iat" | "exp" | "typ">, ttlMinutes: number): string;
+export declare function issueSessionScopedToken(signingSecret: string, payload: Omit<SessionScopedTokenPayload, "iat" | "exp" | "typ">, ttlMinutes: number): string;
 /**
  * Issue a project-scoped token (JWT) for WebSocket authentication.
  * Grants access to all sessions within a single project.
@@ -123,7 +123,7 @@ declare function issueSessionScopedToken(signingSecret: string, payload: Omit<Se
  * @param payload - Token payload with project ID
  * @param ttlMinutes - Token TTL in minutes
  */
-declare function issueProjectScopedToken(signingSecret: string, payload: Omit<ProjectScopedTokenPayload, "iat" | "exp" | "typ">, ttlMinutes: number): string;
+export declare function issueProjectScopedToken(signingSecret: string, payload: Omit<ProjectScopedTokenPayload, "iat" | "exp" | "typ">, ttlMinutes: number): string;
 /**
  * Issue a batch-scoped token (JWT) for WebSocket authentication.
  * Grants access to multiple projects (organization-level access).
@@ -132,7 +132,7 @@ declare function issueProjectScopedToken(signingSecret: string, payload: Omit<Pr
  * @param payload - Token payload with project IDs array
  * @param ttlMinutes - Token TTL in minutes
  */
-declare function issueBatchScopedToken(signingSecret: string, payload: Omit<BatchScopedTokenPayload, "iat" | "exp" | "typ">, ttlMinutes: number): string;
+export declare function issueBatchScopedToken(signingSecret: string, payload: Omit<BatchScopedTokenPayload, "iat" | "exp" | "typ">, ttlMinutes: number): string;
 /**
  * The accepted values of the `cap` claim. The exported union is derived from
  * this list so the type a caller programs against and the set the verifier
@@ -161,7 +161,7 @@ declare const SIDECAR_CAPABILITIES: readonly ["computer_use", "read", "debug", "
  * new value before any issuer stamps it. Sidecars are baked container images
  * that outlive an orchestrator roll, so "ship" means deployed, not merged.
  */
-type SidecarCapability = (typeof SIDECAR_CAPABILITIES)[number];
+export type SidecarCapability = (typeof SIDECAR_CAPABILITIES)[number];
 /**
  * The accepted values of the `sst` claim. The exported union is derived from
  * this list so the type a caller programs against and the set the verifier
@@ -204,7 +204,7 @@ declare const SIDECAR_SID_SCOPES: readonly ["session", "project"];
  * rejects an `sst` it does not recognise, so every verifier must ship the new
  * value before any issuer stamps it.
  */
-type SidecarSidScope = (typeof SIDECAR_SID_SCOPES)[number];
+export type SidecarSidScope = (typeof SIDECAR_SID_SCOPES)[number];
 /**
  * Generate an Ed25519 key pair for per-session JWT signing.
  * Private key stays in orchestrator memory. Public key is injected into
@@ -213,7 +213,7 @@ type SidecarSidScope = (typeof SIDECAR_SID_SCOPES)[number];
  *
  * @returns { privateKey, publicKey } as PEM strings
  */
-declare function generateSidecarKeyPair(): {
+export declare function generateSidecarKeyPair(): {
   privateKey: string;
   publicKey: string;
 };
@@ -226,7 +226,7 @@ declare function generateSidecarKeyPair(): {
  * @param payload - Token payload with container ID
  * @param ttlMinutes - Token TTL in minutes
  */
-declare function issueSidecarAccessToken(privateKey: string, payload: {
+export declare function issueSidecarAccessToken(privateKey: string, payload: {
   sub: string;
   pid: string;
   cid: string;
@@ -251,7 +251,7 @@ declare function issueSidecarAccessToken(privateKey: string, payload: {
  * Verify a sidecar JWT using Ed25519 public key. Rejects non-EdDSA tokens.
  * Returns decoded payload on success, null on failure.
  */
-declare function verifySidecarToken(token: string, publicKey: string, containerId: string): {
+export declare function verifySidecarToken(token: string, publicKey: string, containerId: string): {
   sub: string;
   pid: string;
   cid: string;
@@ -277,34 +277,34 @@ declare function verifySidecarToken(token: string, publicKey: string, containerI
  * Check if a token payload is session-scoped.
  * Session-scoped tokens have a sid claim and no projectId/projectIds.
  */
-declare function isSessionScopedToken(payload: ReadTokenPayload): payload is SessionScopedTokenPayload;
+export declare function isSessionScopedToken(payload: ReadTokenPayload): payload is SessionScopedTokenPayload;
 /**
  * Check if a token payload is project-scoped.
  * Project-scoped tokens have a projectId claim and no sid/projectIds.
  */
-declare function isProjectScopedToken(payload: ReadTokenPayload): payload is ProjectScopedTokenPayload;
+export declare function isProjectScopedToken(payload: ReadTokenPayload): payload is ProjectScopedTokenPayload;
 /**
  * Check if a token payload is batch-scoped.
  * Batch-scoped tokens have a projectIds claim and no sid/projectId.
  */
-declare function isBatchScopedToken(payload: ReadTokenPayload): payload is BatchScopedTokenPayload;
+export declare function isBatchScopedToken(payload: ReadTokenPayload): payload is BatchScopedTokenPayload;
 /**
  * Get the scope of a token payload.
  * Returns null if the token has an invalid/ambiguous scope.
  */
-declare function getTokenScope(payload: ReadTokenPayload): TokenScope | null;
+export declare function getTokenScope(payload: ReadTokenPayload): TokenScope | null;
 /**
  * Validate that a token payload has exactly one valid scope.
  * Returns an error message if invalid, null if valid.
  */
-declare function validateTokenScope(payload: ReadTokenPayload): string | null;
+export declare function validateTokenScope(payload: ReadTokenPayload): string | null;
 /**
  * Verify a read token against a product's signing secrets.
  *
  * @param token - The JWT token to verify
  * @param product - Product auth info containing secrets
  */
-declare function verifyReadToken(token: string, product: ProductAuthInfo): TokenValidationResult;
+export declare function verifyReadToken(token: string, product: ProductAuthInfo): TokenValidationResult;
 /**
  * Hash an API key for storage/lookup.
  * Uses HMAC-SHA256 for consistent, fast hashing.
@@ -312,23 +312,23 @@ declare function verifyReadToken(token: string, product: ProductAuthInfo): Token
  * The salt can be configured via API_KEY_HASH_SALT environment variable.
  * WARNING: Changing the salt will invalidate all existing API key hashes.
  */
-declare function hashApiKey(apiKey: string): string;
+export declare function hashApiKey(apiKey: string): string;
 /**
  * Hash an API key with an explicit salt.
  * Use this when you need to verify against a specific salt.
  */
-declare function hashApiKeyWithSalt(apiKey: string, salt: string): string;
+export declare function hashApiKeyWithSalt(apiKey: string, salt: string): string;
 /**
  * Verify an API key using timing-safe comparison.
  */
-declare function verifyApiKey(provided: string, stored: string): boolean;
+export declare function verifyApiKey(provided: string, stored: string): boolean;
 //#endregion
 //#region src/auth/index.d.ts
 /**
  * Environment-based auth that reads from env vars.
  * Matches the server-side patterns used in sidecar/orchestrator.
  */
-declare class EnvTokenAuth {
+export declare class EnvTokenAuth {
   private envVar;
   private fallback?;
   constructor(options: {
@@ -341,14 +341,14 @@ declare class EnvTokenAuth {
  * Pre-configured auth for sidecar connections.
  * Uses SIDECAR_AUTH_TOKEN env var (matches server expectation).
  */
-declare class SidecarAuth extends EnvTokenAuth {
+export declare class SidecarAuth extends EnvTokenAuth {
   constructor(token?: string);
 }
 /**
  * Product-based auth for multi-tenant orchestrator connections.
  * Uses ORCHESTRATOR_API_SECRET_KEY env var.
  */
-declare class ProductAuth extends EnvTokenAuth {
+export declare class ProductAuth extends EnvTokenAuth {
   constructor(apiKey?: string);
 }
 /**
@@ -381,7 +381,7 @@ declare class ProductAuth extends EnvTokenAuth {
  * });
  * ```
  */
-declare class ProductTokenIssuer {
+export declare class ProductTokenIssuer {
   private readonly productId;
   private readonly signingSecret;
   private readonly ttlMinutes;
@@ -413,5 +413,5 @@ declare class ProductTokenIssuer {
   getTtlMinutes(tier?: "free" | "pro" | "enterprise"): number;
 }
 //#endregion
-export { type AuthProvider, BatchScopedTokenPayload, BatchScopedTokenPayloadSchema, CallbackAuth, ChannelAccessResult, CreateSessionRequest, CreateSessionRequestSchema, CreateSessionResponse, EnvTokenAuth, NoAuth, Product, ProductAuth, ProductAuthInfo, ProductSchema, ProductSecrets, ProductTokenIssuer, ProjectScopedTokenPayload, ProjectScopedTokenPayloadSchema, ReadTokenAuth, ReadTokenPayload, ReadTokenPayloadSchema, RefreshableTokenAuth, SendMessageRequest, SendMessageRequestSchema, SessionScopedTokenPayload, SessionScopedTokenPayloadSchema, SidecarAuth, SidecarCapability, SidecarSidScope, StaticTokenAuth, TokenScope, TokenValidationResult, canBatchTokenAccessChannel, canProjectTokenAccessChannel, canSessionTokenAccessChannel, canTokenAccessChannel, decodeToken, extractProjectFromChannel, extractSessionFromChannel, generateApiKey, generateSecureToken, generateSidecarKeyPair, generateSigningSecret, getAllowedChannelPatterns, getTokenScope, getTokenTTL, hashApiKey, hashApiKeyWithSalt, isBatchScopedToken, isProjectScopedToken, isSessionScopedToken, isTokenExpiringSoon, issueBatchScopedToken, issueProjectScopedToken, issueReadToken, issueSessionScopedToken, issueSidecarAccessToken, validateChannelSubscription, validateTokenScope, verifyApiKey, verifyReadToken, verifySidecarToken };
+export { type AuthProvider, BatchScopedTokenPayload, BatchScopedTokenPayloadSchema, CallbackAuth, CreateSessionRequest, CreateSessionRequestSchema, CreateSessionResponse, NoAuth, Product, ProductAuthInfo, ProductSchema, ProductSecrets, ProjectScopedTokenPayload, ProjectScopedTokenPayloadSchema, ReadTokenAuth, ReadTokenPayload, ReadTokenPayloadSchema, RefreshableTokenAuth, SendMessageRequest, SendMessageRequestSchema, SessionScopedTokenPayload, SessionScopedTokenPayloadSchema, StaticTokenAuth, TokenScope, TokenValidationResult, decodeToken, getTokenTTL, isTokenExpiringSoon };
 //# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/auth/channel-access.ts","../../src/auth/tokens.ts","../../src/auth/index.ts"],"mappings":";;;;;UA4BiB;;EAEf;;EAEA;;;;;;iBAOc,0BAA0B;;;;;iBAc1B,0BAA0B;;;;;;;;;;iBAgB1B,6BACd,SAAS,2BACT,kBACC;;;;;;;;;;iBAuDa,6BACd,SAAS,2BACT,kBACC;;;;;;;;;;;iBAsDa,2BACd,SAAS,yBACT,kBACC;;;;;;;;;iBA8Ca,sBACd,SAAS,kBACT,kBACC;;;;;;;;iBA4Ba,0BAA0B,SAAS;;;;;;;;;iBAwCnC,4BACd,SAAS,kBACT;EAEA;EACA,QAAQ;IAAQ;IAAiB;;;;;;;;;;iBCxPnB,oBAAoB,gBAAgB;;;;iBAOpC;;;;iBAOA;;;;;;;;iBAgFA,eACd,uBACA,SAAS,KAAK,0CACd;;;;;;;;;iBA6Bc,wBACd,uBACA,SAAS,KAAK,mDACd;;;;;;;;;iBAac,wBACd,uBACA,SAAS,KAAK,mDACd;;;;;;;;;iBAiBc,sBACd,uBACA,SAAS,KAAK,iDACd;;;;;;cA0BI;;;;;;;;;;;;;;;;;;;;;;;KAgCM,4BAA4B;;;;;;cA4BlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsCM,0BAA0B;;;;;;;;;iBAUtB;EACd;EACA;;;;;;;;;;;iBAqBc,wBACd,oBACA;EACE;EACA;EACA;EACA;;;;;;;EAOA,MAAM;;;;;;;;EAQN,MAAM;GAER;;;;;iBA4Dc,mBACd,eACA,mBACA;EAEA;EACA;EACA;EACA;;;;;EAKA,MAAM;EACN;EACA;EACA;;;;;;;;EAQA,MAAM;;;;;;iBAoIQ,qBACd,SAAS,mBACR,WAAW;;;;;iBAcE,qBACd,SAAS,mBACR,WAAW;;;;;iBAcE,mBACd,SAAS,mBACR,WAAW;;;;;iBAcE,cAAc,SAAS,mBAAmB;;;;;iBAW1C,mBAAmB,SAAS;;;;;;;iBA6B5B,gBACd,eACA,SAAS,kBACR;;;;;;;;iBA6Ka,WAAW;;;;;iBAWX,mBAAmB,gBAAgB;;;;iBAOnC,aAAa,kBAAkB;;;;;;;cC72BlC;UACH;UACA;EAER,YAAY;IAAW;IAAgB;;EAKjC,YAAY;;;;;;cAaP,oBAAoB;EAC/B,YAAY;;;;;;cASD,oBAAoB;EAC/B,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCD;mBACM;mBACA;mBACA;EAMjB,YAAY;IACV;IACA;;IAEA;MAAe;MAAe;MAAc;;;;;;EAc9C,MAAM;IACJ;IACA;IACA;IACA;;IACI;IAAe;;;;;EAuBrB,cAAc"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/auth/channel-access.ts","../../src/auth/tokens.ts","../../src/auth/index.ts"],"mappings":";;;;;iBA4BiB;;EAEf;;EAEA;;;;;;wBAOc,0BAA0B;;;;;wBAc1B,0BAA0B;;;;;;;;;;wBAgB1B,6BACd,SAAS,2BACT,kBACC;;;;;;;;;;wBAuDa,6BACd,SAAS,2BACT,kBACC;;;;;;;;;;;wBAsDa,2BACd,SAAS,yBACT,kBACC;;;;;;;;;wBA8Ca,sBACd,SAAS,kBACT,kBACC;;;;;;;;wBA4Ba,0BAA0B,SAAS;;;;;;;;;wBAwCnC,4BACd,SAAS,kBACT;EAEA;EACA,QAAQ;IAAQ;IAAiB;;;;;;;;;;wBCxPnB,oBAAoB,gBAAgB;;;;wBAOpC;;;;wBAOA;;;;;;;;wBAgFA,eACd,uBACA,SAAS,KAAK,0CACd;;;;;;;;;wBA6Bc,wBACd,uBACA,SAAS,KAAK,mDACd;;;;;;;;;wBAac,wBACd,uBACA,SAAS,KAAK,mDACd;;;;;;;;;wBAiBc,sBACd,uBACA,SAAS,KAAK,iDACd;;;;;;cA0BI;;;;;;;;;;;;;;;;;;;;;;;YAgCM,4BAA4B;;;;;;cA4BlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsCM,0BAA0B;;;;;;;;;wBAUtB;EACd;EACA;;;;;;;;;;;wBAqBc,wBACd,oBACA;EACE;EACA;EACA;EACA;;;;;;;EAOA,MAAM;;;;;;;;EAQN,MAAM;GAER;;;;;wBA4Dc,mBACd,eACA,mBACA;EAEA;EACA;EACA;EACA;;;;;EAKA,MAAM;EACN;EACA;EACA;;;;;;;;EAQA,MAAM;;;;;;wBAoIQ,qBACd,SAAS,mBACR,WAAW;;;;;wBAcE,qBACd,SAAS,mBACR,WAAW;;;;;wBAcE,mBACd,SAAS,mBACR,WAAW;;;;;wBAcE,cAAc,SAAS,mBAAmB;;;;;wBAW1C,mBAAmB,SAAS;;;;;;;wBA6B5B,gBACd,eACA,SAAS,kBACR;;;;;;;;wBA6Ka,WAAW;;;;;wBAWX,mBAAmB,gBAAgB;;;;wBAOnC,aAAa,kBAAkB;;;;;;;qBC72BlC;UACH;UACA;EAER,YAAY;IAAW;IAAgB;;EAKjC,YAAY;;;;;;qBAaP,oBAAoB;EAC/B,YAAY;;;;;;qBASD,oBAAoB;EAC/B,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCD;mBACM;mBACA;mBACA;EAMjB,YAAY;IACV;IACA;;IAEA;MAAe;MAAe;MAAc;;;;;;EAc9C,MAAM;IACJ;IACA;IACA;IACA;;IACI;IAAe;;;;;EAuBrB,cAAc"}

package/dist/computer-use/index.d.ts

@@ -54,7 +54,7 @@ type ComputerUseAction = {
   ms: number;
 };
 type ComputerUseActionType = ComputerUseAction["type"];
-declare class ComputerUseError extends Error {
+export declare class ComputerUseError extends Error {
   readonly code: string;
   constructor(message: string, code?: string);
 }
@@ -64,7 +64,7 @@ declare class ComputerUseError extends Error {
  * with `instanceof` to surface the failure as a tool result rather
  * than a 5xx.
  */
-declare class ComputerActionTranslationError extends Error {
+export declare class ComputerActionTranslationError extends Error {
   readonly code: string;
   constructor(message: string, code?: string);
 }
@@ -73,8 +73,8 @@ declare class ComputerActionTranslationError extends Error {
  * Throws ComputerUseError with COMPUTER_USE_INVALID_ACTION on any
  * structural problem.
  */
-declare function parseAction(input: unknown): ComputerUseAction;
-declare function normalizeKey(key: string): string;
+export declare function parseAction(input: unknown): ComputerUseAction;
+export declare function normalizeKey(key: string): string;
 //#endregion
 //#region src/computer-use/anthropic.d.ts
 interface AnthropicComputerInput {
@@ -92,7 +92,7 @@ interface AnthropicComputerInput {
  * unrecognized action names; the caller should surface the error as a
  * tool_result with `is_error: true` so the model can react.
  */
-declare function translateAnthropicComputerAction(input: AnthropicComputerInput): ComputerUseAction;
+export declare function translateAnthropicComputerAction(input: AnthropicComputerInput): ComputerUseAction;
 //#endregion
 //#region src/computer-use/openai.d.ts
 interface OpenAIComputerInput {
@@ -116,7 +116,7 @@ interface OpenAIComputerInput {
  * action. Throws `ComputerActionTranslationError` for unsupported
  * variants (wheel/back/forward buttons) or malformed inputs.
  */
-declare function translateOpenAIComputerAction(input: OpenAIComputerInput): ComputerUseAction;
+export declare function translateOpenAIComputerAction(input: OpenAIComputerInput): ComputerUseAction;
 //#endregion
-export { type AnthropicComputerInput, ComputerActionTranslationError, type ComputerUseAction, type ComputerUseActionType, ComputerUseError, type MouseButton, type OpenAIComputerInput, normalizeKey, parseAction, translateAnthropicComputerAction, translateOpenAIComputerAction };
+export type { AnthropicComputerInput, ComputerUseAction, ComputerUseActionType, MouseButton, OpenAIComputerInput };
 //# sourceMappingURL=index.d.ts.map

package/dist/computer-use/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/computer-use/action.ts","../../src/computer-use/anthropic.ts","../../src/computer-use/openai.ts"],"mappings":";;;;;;;;;;KAUY;KAEA;EACN;;EACA;;EACA;EAAe;EAAW;EAAW,SAAS;;EAC9C;EAAsB;EAAW;;EACjC;EAAc;EAAW;;EAEzB;EACA;IAAQ;IAAW;;EACnB;IAAM;IAAW;;;EAEjB;EAAc;EAAc;;EAC5B;EAAkB;;EAElB;EACA;EACA;EACA;EACA;;EAEA;EAAc;;KAER,wBAAwB;cAEvB,yBAAyB;WAC3B;EACT,YAAY,iBAAiB;;;;;;;;cAalB,uCAAuC;WACzC;EACT,YAAY,iBAAiB;;;;;;;iBAyCf,YAAY,iBAAiB;iBAqM7B,aAAa;;;UChRZ;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;iBAsCc,iCACd,OAAO,yBACN;;;UCxCc;EACf;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;IAAQ;IAAW;;EAC1B;EACA;EACA;EACA;;;;;;;iBAyBc,8BACd,OAAO,sBACN"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/computer-use/action.ts","../../src/computer-use/anthropic.ts","../../src/computer-use/openai.ts"],"mappings":";;;;;;;;;;KAUY;KAEA;EACN;;EACA;;EACA;EAAe;EAAW;EAAW,SAAS;;EAC9C;EAAsB;EAAW;;EACjC;EAAc;EAAW;;EAEzB;EACA;IAAQ;IAAW;;EACnB;IAAM;IAAW;;;EAEjB;EAAc;EAAc;;EAC5B;EAAkB;;EAElB;EACA;EACA;EACA;EACA;;EAEA;EAAc;;KAER,wBAAwB;qBAEvB,yBAAyB;WAC3B;EACT,YAAY,iBAAiB;;;;;;;;qBAalB,uCAAuC;WACzC;EACT,YAAY,iBAAiB;;;;;;;wBAyCf,YAAY,iBAAiB;wBAqM7B,aAAa;;;UChRZ;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;wBAsCc,iCACd,OAAO,yBACN;;;UCxCc;EACf;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;IAAQ;IAAW;;EAC1B;EACA;EACA;EACA;;;;;;;wBAyBc,8BACd,OAAO,sBACN"}

package/dist/index.d.ts

@@ -37,7 +37,7 @@ interface CacheStorage<T = unknown> {
   clear(): void | Promise<void>;
 }
 /** In-memory LRU cache */
-declare class MemoryCache<T = unknown> implements CacheStorage<CacheEntry<T>> {
+export declare class MemoryCache<T = unknown> implements CacheStorage<CacheEntry<T>> {
   private cache;
   private readonly maxEntries;
   constructor(maxEntries?: number);
@@ -52,7 +52,7 @@ declare class MemoryCache<T = unknown> implements CacheStorage<CacheEntry<T>> {
   };
 }
 /** Response cache manager */
-declare class ResponseCache<T = unknown> {
+export declare class ResponseCache<T = unknown> {
   private storage;
   private defaultTtlMs;
   private keyGenerator;
@@ -130,7 +130,7 @@ interface Interceptor {
   onError?(ctx: ErrorContext): void | Promise<void>;
 }
 /** Interceptor chain executor */
-declare class InterceptorChain {
+export declare class InterceptorChain {
   private interceptors;
   /** Add interceptor to chain */
   use(interceptor: Interceptor): this;
@@ -144,15 +144,15 @@ declare class InterceptorChain {
   executeError(ctx: ErrorContext): Promise<void>;
 }
 /** Generate unique request ID */
-declare function generateRequestId(): string;
+export declare function generateRequestId(): string;
 /** Logging interceptor */
-declare function createLoggingInterceptor(logger?: {
+export declare function createLoggingInterceptor(logger?: {
   debug?(msg: string, data?: unknown): void;
   info?(msg: string, data?: unknown): void;
   error?(msg: string, data?: unknown): void;
 }): Interceptor;
 /** Metrics interceptor */
-declare function createMetricsInterceptor(onMetric: (metric: {
+export declare function createMetricsInterceptor(onMetric: (metric: {
   path: string;
   method: string;
   status: "success" | "error";
@@ -160,7 +160,7 @@ declare function createMetricsInterceptor(onMetric: (metric: {
   errorCode?: string;
 }) => void): Interceptor;
 /** Header injection interceptor */
-declare function createHeaderInterceptor(headers: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>)): Interceptor;
+export declare function createHeaderInterceptor(headers: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>)): Interceptor;
 //#endregion
 //#region src/storage/index.d.ts
 /**
@@ -177,7 +177,7 @@ interface Storage {
   keys(): Promise<string[]>;
 }
 /** In-memory storage (default fallback) */
-declare class MemoryStorage implements Storage {
+export declare class MemoryStorage implements Storage {
   private data;
   get<T>(key: string): Promise<T | null>;
   set<T>(key: string, value: T): Promise<void>;
@@ -186,7 +186,7 @@ declare class MemoryStorage implements Storage {
   keys(): Promise<string[]>;
 }
 /** Browser localStorage wrapper */
-declare class LocalStorage implements Storage {
+export declare class LocalStorage implements Storage {
   private prefix;
   constructor(prefix?: string);
   private key;
@@ -208,7 +208,7 @@ interface QueuedRequest {
   idempotencyKey?: string;
 }
 /** Offline queue manager */
-declare class OfflineQueue {
+export declare class OfflineQueue {
   private storage;
   private readonly storageKey;
   constructor(storage: Storage);
@@ -236,7 +236,7 @@ declare class OfflineQueue {
   }>;
 }
 /** Detect available storage */
-declare function detectStorage(): Storage;
+export declare function detectStorage(): Storage;
 //#endregion
 //#region src/platform/index.d.ts
 /**
@@ -330,7 +330,7 @@ interface PlatformAdapter {
  * In-memory secure storage fallback.
  * NOT SECURE - use only for development/testing.
  */
-declare class MemorySecureStorage implements SecureStorage {
+export declare class MemorySecureStorage implements SecureStorage {
   private credentials;
   setCredential(key: string, value: string): Promise<void>;
   getCredential(key: string): Promise<string | null>;
@@ -340,7 +340,7 @@ declare class MemorySecureStorage implements SecureStorage {
 /**
  * Browser-based network info using navigator.onLine.
  */
-declare class BrowserNetworkInfo implements NetworkInfo {
+export declare class BrowserNetworkInfo implements NetworkInfo {
   isOnline(): boolean;
   onConnectivityChange(callback: (online: boolean) => void): () => void;
   getConnectionType(): "wifi" | "cellular" | "ethernet" | "unknown";
@@ -348,7 +348,7 @@ declare class BrowserNetworkInfo implements NetworkInfo {
 /**
  * Node.js network info (assumes always online).
  */
-declare class NodeNetworkInfo implements NetworkInfo {
+export declare class NodeNetworkInfo implements NetworkInfo {
   isOnline(): boolean;
   onConnectivityChange(_callback: (online: boolean) => void): () => void;
 }
@@ -356,7 +356,7 @@ declare class NodeNetworkInfo implements NetworkInfo {
  * Storage-based persistence adapter.
  * Uses provided Storage implementation for state persistence.
  */
-declare class StoragePersistence implements PersistenceAdapter {
+export declare class StoragePersistence implements PersistenceAdapter {
   private storage;
   constructor(storage: Storage);
   saveState<T>(namespace: string, state: T): Promise<void>;
@@ -366,7 +366,7 @@ declare class StoragePersistence implements PersistenceAdapter {
 /**
  * Browser persistence with localStorage and storage events for tab sync.
  */
-declare class BrowserPersistence implements PersistenceAdapter {
+export declare class BrowserPersistence implements PersistenceAdapter {
   private prefix;
   constructor(prefix?: string);
   saveState<T>(namespace: string, state: T): Promise<void>;
@@ -377,17 +377,17 @@ declare class BrowserPersistence implements PersistenceAdapter {
 /**
  * Detect current platform.
  */
-declare function detectPlatform(): PlatformCapabilities["platform"];
+export declare function detectPlatform(): PlatformCapabilities["platform"];
 /**
  * Create default platform adapter for current environment.
  * Override with platform-specific implementations for better integration.
  */
-declare function createDefaultPlatformAdapter(): PlatformAdapter;
+export declare function createDefaultPlatformAdapter(): PlatformAdapter;
 /**
  * Type-safe platform adapter factory.
  * Use this to create platform adapters with proper typing.
  */
-declare function createPlatformAdapter(config: Partial<PlatformAdapter> & {
+export declare function createPlatformAdapter(config: Partial<PlatformAdapter> & {
   capabilities: PlatformCapabilities;
 }): PlatformAdapter;
 //#endregion
@@ -412,13 +412,13 @@ interface RetryConfig {
   signal?: AbortSignal;
 }
 /** Calculate delay for attempt with jitter */
-declare function calculateDelay(attempt: number, config: RetryConfig): number;
+export declare function calculateDelay(attempt: number, config: RetryConfig): number;
 /** Execute function with retry */
-declare function withRetry<T>(fn: (attempt: number) => Promise<T>, config?: RetryConfig): Promise<T>;
+export declare function withRetry<T>(fn: (attempt: number) => Promise<T>, config?: RetryConfig): Promise<T>;
 /** Idempotency key generator */
-declare function generateIdempotencyKey(): string;
+export declare function generateIdempotencyKey(): string;
 /** Retry decorator for class methods */
-declare function Retryable(config?: RetryConfig): <T>(_target: object, _propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: unknown[]) => Promise<T>>) => TypedPropertyDescriptor<(...args: unknown[]) => Promise<T>>;
+export declare function Retryable(config?: RetryConfig): <T>(_target: object, _propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: unknown[]) => Promise<T>>) => TypedPropertyDescriptor<(...args: unknown[]) => Promise<T>>;
 //#endregion
 //#region src/utils/channel-matching.d.ts
 /**
@@ -441,7 +441,7 @@ declare function Retryable(config?: RetryConfig): <T>(_target: object, _property
  * @param channel - The channel name to check
  * @returns true if the pattern matches the channel
  */
-declare function matchesChannel(pattern: string, channel: string): boolean;
+export declare function matchesChannel(pattern: string, channel: string): boolean;
 /**
  * Check if any subscribed channel pattern matches the given channel.
  *
@@ -449,7 +449,7 @@ declare function matchesChannel(pattern: string, channel: string): boolean;
  * @param channel - The channel to check
  * @returns true if any pattern matches the channel
  */
-declare function matchesAnyChannel(subscribedChannels: Set<string> | string[], channel: string): boolean;
+export declare function matchesAnyChannel(subscribedChannels: Set<string> | string[], channel: string): boolean;
 //#endregion
 //#region src/utils/session-translator.d.ts
 /**
@@ -472,18 +472,18 @@ interface SessionTranslation {
  * @param translation - The session ID mapping
  * @returns A new event object with translated session IDs
  */
-declare function translateSessionId<T>(event: T, translation: SessionTranslation): T;
+export declare function translateSessionId<T>(event: T, translation: SessionTranslation): T;
 /**
  * Create a reusable translator function for a specific session mapping.
  * Pre-compiles the regex pattern for better performance when translating
  * many events with the same mapping.
  */
-declare function createSessionTranslator(translation: SessionTranslation): <T>(event: T) => T;
+export declare function createSessionTranslator(translation: SessionTranslation): <T>(event: T) => T;
 /**
  * Extract session ID from various event structures.
  * Handles different event formats that may contain session information.
  */
-declare function extractSessionId(event: unknown): string | null;
+export declare function extractSessionId(event: unknown): string | null;
 //#endregion
-export { type AgentEvent, type AgentEventType, AgentEventTypeSchema, type AuthProvider, BaseTransportAdapter, type BatchScopedTokenPayload, BatchScopedTokenPayloadSchema, BrowserNetworkInfo, BrowserPersistence, type BufferedEvent, CONTENT_COMPLETION_KEY, CONTENT_KEYS, CONTENT_KEY_FIELD, CONTENT_PROMPT_KEY, CONTENT_TOOL_ARGS_KEY, CONTENT_TOOL_NAME_KEY, CONTENT_TOOL_RESULT_KEY, type CacheConfig, type CacheStorage, CallbackAuth, type ChannelAccessResult, type ChannelConfig, type ChannelHandler, CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerStats, CircuitOpenError, type CircuitState, type ConnectionInitEvent, ConnectionManager, type ConnectionManagerConfig, type ConnectionQuality, type ConnectionState, type ContentField, type CreateSessionRequest, CreateSessionRequestSchema, type CreateSessionResponse, DEFAULT_RECONNECTION_CONFIG, type DeclaredIntentMatch, type DeduplicatorConfig, type DoneEvent, EnvTokenAuth, type ErrorCode, type ErrorContext, type ErrorEvent, EventBuffer, type EventBufferConfig, EventChannel, EventDeduplicator, type EventMetadata, type ExecutionCompletedEvent, type ExecutionFailedEvent, type ExecutionStartedEvent, type FilePart, GEN_AI_CONVERSATION_ID, GEN_AI_INPUT_TOKEN_KEYS, GEN_AI_MODEL_KEYS, GEN_AI_OPERATION_NAME, GEN_AI_OUTPUT_TOKEN_KEYS, GEN_AI_REQUEST_MODEL, GEN_AI_RESPONSE_MODEL, GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS, GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, type GenAiUsage, type HeartbeatEvent, INDEXED_CONTENT_KEY_LIKE_PATTERNS, type Interceptor, InterceptorChain, LocalStorage, MemoryCache, MemorySecureStorage, MemoryStorage, type MessagePartUpdatedEvent, type MockResponse, type MockStreamEvent, MockTransportAdapter, type MockTransportConfig, type NetworkInfo, NoAuth, NodeNetworkInfo, type NormalizedContent, OfflineQueue, PARENT_RUN_KEY_ATTRS, type ParsedSSEEvent, type Part, type PartBase, type PersistenceAdapter, type PlatformAdapter, type PlatformCapabilities, type Product, ProductAuth, type ProductAuthInfo, ProductSchema, type ProductSecrets, ProductTokenIssuer, type ProjectScopedTokenPayload, ProjectScopedTokenPayloadSchema, type ProtectionOptions, type QueuedRequest, RUN_KEY_ATTRS, RUN_KIND_ATTRS, ReadTokenAuth, type ReadTokenPayload, ReadTokenPayloadSchema, type ReasoningPart, type ReconnectionConfig, type RecordedRequest, RefreshableTokenAuth, type ReplayEndEvent, type ReplayStartEvent, type RequestContext, type RequestOptions, ResponseCache, type ResponseContext, type ResultEvent, type RetryConfig, Retryable, SDKError, SSEChunkParser, type SSEEvent, type SSEEventData, type SSEParserOptions, SUBJECT_KEY_ATTRS, type SecureStorage, type SendMessageRequest, SendMessageRequestSchema, type SessionScopedTokenPayload, SessionScopedTokenPayloadSchema, type SessionTranslation, type SessionUpdatedEvent, SidecarAuth, StaticTokenAuth, type StatusEvent, type Storage, StoragePersistence, type StreamOptions, type StreamTokenUsage, type StreamUsageAccumulator, StreamUsageExtractor, type Subscription, type SubscriptionState, type SubtaskPart, TANGLE_RUN_ID_CAMEL_KEY, TANGLE_RUN_ID_KEY, TANGLE_RUN_KIND_KEY, TANGLE_RUN_PARENT_ID_KEY, TANGLE_SUBJECT_KEY, TANGLE_TRIGGER_ID_KEY, TANGLE_TRIGGER_KIND_KEY, TANGLE_TRIGGER_SOURCE_KEY, TANGLE_WORKFLOW_ID_KEY, TOKEN_USAGE_CACHE_BAG_KEYS, TOKEN_USAGE_CACHE_BAG_READ_KEYS, TOKEN_USAGE_CACHE_BAG_WRITE_KEYS, TOKEN_USAGE_CACHE_READ_EXCLUSIVE_KEYS, TOKEN_USAGE_CACHE_READ_INCLUSIVE_KEYS, TOKEN_USAGE_CACHE_WRITE_EXCLUSIVE_KEYS, TOKEN_USAGE_CACHE_WRITE_INCLUSIVE_KEYS, TOKEN_USAGE_COST_KEYS, TOKEN_USAGE_DETAIL_KEYS, TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, TRIGGER_ID_ATTRS, TRIGGER_SOURCE_ATTRS, type TerminalDataEvent, type TerminalEvent, type TerminalExitEvent, type TerminalResizeEvent, type TextPart, TimeoutError, type TokenScope, type TokenUsageCounts, type TokenValidationResult, type ToolPart, type ToolState, type ToolStateCompleted, type ToolStateError, type ToolStatePending, type ToolStateRunning, type TransportAdapter, type TransportConfig, type TransportEvents, type TransportMetrics, type TransportMode, WORKFLOW_MARKER_ATTRS, addTokenUsage, asContentField, asContentString, cacheHitRate, calculateDelay, canBatchTokenAccessChannel, canProjectTokenAccessChannel, canSessionTokenAccessChannel, canTokenAccessChannel, classifyAgent, consumeSSEStream, createDefaultPlatformAdapter, createHeaderInterceptor, createLoggingInterceptor, createMetricsInterceptor, createPlatformAdapter, createProtectedFn, createSessionTranslator, createStreamUsageExtractor, createTimeoutController, createUsageCallback, declaredTaskText, decodeToken, detectPlatform, detectStorage, extractContent, extractProjectFromChannel, extractSessionFromChannel, extractSessionId, firstTokenCount, firstUsageCostUsd, genAiUsageAttributes, generateApiKey, generateIdempotencyKey, generateRequestId, generateSecureToken, generateSigningSecret, getAllowedChannelPatterns, getTokenScope, getTokenTTL, hasContent, hashApiKey, isBatchScopedToken, isFilePart, isProjectScopedToken, isReasoningPart, isRetryable, isSDKError, isSessionScopedToken, isSubtaskPart, isTextPart, isTokenExpiringSoon, isToolPart, issueBatchScopedToken, issueProjectScopedToken, issueReadToken, issueSessionScopedToken, logRecordContentBag, matchesAnyChannel, matchesChannel, normalizeContentAttributes, parseSSEData, parseSSEStream, promptTokens, readTokenCostUsd, readTokenUsage, resolveDeclaredIntent, sleep, tokenCount, tokenUsageSource, translateSessionId, validateChannelSubscription, validateTokenScope, verifyApiKey, verifyReadToken, withProtection, withRetry, withTimeout };
+export { type AgentEvent, type AgentEventType, AgentEventTypeSchema, type AuthProvider, BaseTransportAdapter, type BatchScopedTokenPayload, BatchScopedTokenPayloadSchema, type BufferedEvent, CONTENT_COMPLETION_KEY, CONTENT_KEYS, CONTENT_KEY_FIELD, CONTENT_PROMPT_KEY, CONTENT_TOOL_ARGS_KEY, CONTENT_TOOL_NAME_KEY, CONTENT_TOOL_RESULT_KEY, type CacheConfig, type CacheStorage, CallbackAuth, type ChannelAccessResult, type ChannelConfig, type ChannelHandler, CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerStats, CircuitOpenError, type CircuitState, type ConnectionInitEvent, ConnectionManager, type ConnectionManagerConfig, type ConnectionQuality, type ConnectionState, type ContentField, type CreateSessionRequest, CreateSessionRequestSchema, type CreateSessionResponse, DEFAULT_RECONNECTION_CONFIG, type DeclaredIntentMatch, type DeduplicatorConfig, type DoneEvent, EnvTokenAuth, type ErrorCode, type ErrorContext, type ErrorEvent, EventBuffer, type EventBufferConfig, EventChannel, EventDeduplicator, type EventMetadata, type ExecutionCompletedEvent, type ExecutionFailedEvent, type ExecutionStartedEvent, type FilePart, GEN_AI_CONVERSATION_ID, GEN_AI_INPUT_TOKEN_KEYS, GEN_AI_MODEL_KEYS, GEN_AI_OPERATION_NAME, GEN_AI_OUTPUT_TOKEN_KEYS, GEN_AI_REQUEST_MODEL, GEN_AI_RESPONSE_MODEL, GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS, GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, type GenAiUsage, type HeartbeatEvent, INDEXED_CONTENT_KEY_LIKE_PATTERNS, type Interceptor, type MessagePartUpdatedEvent, type MockResponse, type MockStreamEvent, MockTransportAdapter, type MockTransportConfig, type NetworkInfo, NoAuth, type NormalizedContent, PARENT_RUN_KEY_ATTRS, type ParsedSSEEvent, type Part, type PartBase, type PersistenceAdapter, type PlatformAdapter, type PlatformCapabilities, type Product, ProductAuth, type ProductAuthInfo, ProductSchema, type ProductSecrets, ProductTokenIssuer, type ProjectScopedTokenPayload, ProjectScopedTokenPayloadSchema, type ProtectionOptions, type QueuedRequest, RUN_KEY_ATTRS, RUN_KIND_ATTRS, ReadTokenAuth, type ReadTokenPayload, ReadTokenPayloadSchema, type ReasoningPart, type ReconnectionConfig, type RecordedRequest, RefreshableTokenAuth, type ReplayEndEvent, type ReplayStartEvent, type RequestContext, type RequestOptions, type ResponseContext, type ResultEvent, type RetryConfig, SDKError, SSEChunkParser, type SSEEvent, type SSEEventData, type SSEParserOptions, SUBJECT_KEY_ATTRS, type SecureStorage, type SendMessageRequest, SendMessageRequestSchema, type SessionScopedTokenPayload, SessionScopedTokenPayloadSchema, type SessionTranslation, type SessionUpdatedEvent, SidecarAuth, StaticTokenAuth, type StatusEvent, type Storage, type StreamOptions, type StreamTokenUsage, type StreamUsageAccumulator, StreamUsageExtractor, type Subscription, type SubscriptionState, type SubtaskPart, TANGLE_RUN_ID_CAMEL_KEY, TANGLE_RUN_ID_KEY, TANGLE_RUN_KIND_KEY, TANGLE_RUN_PARENT_ID_KEY, TANGLE_SUBJECT_KEY, TANGLE_TRIGGER_ID_KEY, TANGLE_TRIGGER_KIND_KEY, TANGLE_TRIGGER_SOURCE_KEY, TANGLE_WORKFLOW_ID_KEY, TOKEN_USAGE_CACHE_BAG_KEYS, TOKEN_USAGE_CACHE_BAG_READ_KEYS, TOKEN_USAGE_CACHE_BAG_WRITE_KEYS, TOKEN_USAGE_CACHE_READ_EXCLUSIVE_KEYS, TOKEN_USAGE_CACHE_READ_INCLUSIVE_KEYS, TOKEN_USAGE_CACHE_WRITE_EXCLUSIVE_KEYS, TOKEN_USAGE_CACHE_WRITE_INCLUSIVE_KEYS, TOKEN_USAGE_COST_KEYS, TOKEN_USAGE_DETAIL_KEYS, TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, TRIGGER_ID_ATTRS, TRIGGER_SOURCE_ATTRS, type TerminalDataEvent, type TerminalEvent, type TerminalExitEvent, type TerminalResizeEvent, type TextPart, TimeoutError, type TokenScope, type TokenUsageCounts, type TokenValidationResult, type ToolPart, type ToolState, type ToolStateCompleted, type ToolStateError, type ToolStatePending, type ToolStateRunning, type TransportAdapter, type TransportConfig, type TransportEvents, type TransportMetrics, type TransportMode, WORKFLOW_MARKER_ATTRS, addTokenUsage, asContentField, asContentString, cacheHitRate, canBatchTokenAccessChannel, canProjectTokenAccessChannel, canSessionTokenAccessChannel, canTokenAccessChannel, classifyAgent, consumeSSEStream, createProtectedFn, createStreamUsageExtractor, createTimeoutController, createUsageCallback, declaredTaskText, decodeToken, extractContent, extractProjectFromChannel, extractSessionFromChannel, firstTokenCount, firstUsageCostUsd, genAiUsageAttributes, generateApiKey, generateSecureToken, generateSigningSecret, getAllowedChannelPatterns, getTokenScope, getTokenTTL, hasContent, hashApiKey, isBatchScopedToken, isFilePart, isProjectScopedToken, isReasoningPart, isRetryable, isSDKError, isSessionScopedToken, isSubtaskPart, isTextPart, isTokenExpiringSoon, isToolPart, issueBatchScopedToken, issueProjectScopedToken, issueReadToken, issueSessionScopedToken, logRecordContentBag, normalizeContentAttributes, parseSSEData, parseSSEStream, promptTokens, readTokenCostUsd, readTokenUsage, resolveDeclaredIntent, sleep, tokenCount, tokenUsageSource, validateChannelSubscription, validateTokenScope, verifyApiKey, verifyReadToken, withProtection, withTimeout };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/cache/index.ts","../src/middleware/index.ts","../src/storage/index.ts","../src/platform/index.ts","../src/retry/index.ts","../src/utils/channel-matching.ts","../src/utils/session-translator.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/cache/index.ts","../src/middleware/index.ts","../src/storage/index.ts","../src/platform/index.ts","../src/retry/index.ts","../src/utils/channel-matching.ts","../src/utils/session-translator.ts"],"mappings":"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"}

package/dist/interactions/index.d.ts

@@ -7,7 +7,7 @@ import { InteractionExecutionBinding, StreamEvent } from "@tangle-network/agent-
  * Extensions call `/permission` or `/question`. The bridge blocks until the
  * shared broker receives an operator response.
  */
-declare class InteractionHttpBridge {
+export declare class InteractionHttpBridge {
   readonly token: string;
   private readonly requestPermission;
   private readonly askUser;
@@ -29,5 +29,5 @@ declare class InteractionHttpBridge {
   private route;
 }
 //#endregion
-export { type AskUserBridge, type BrokerInteractionTools, DEFAULT_INTERACTION_DECISION_TIMEOUT_MS, InteractionBroker, type InteractionBrokerOptions, InteractionHttpBridge, type InteractionQuestion, InteractionQuestionSchema, MAX_INTERACTION_DECISION_TIMEOUT_MS, type PermissionPromptBridge, type RequestPermissionBridge, type RequestPlanBridge, brokerInteractionTools, coercePermissionGrant, interactionAnswerSpecForQuestions, interactionDataToQuestionAnswers };
+export { type AskUserBridge, type BrokerInteractionTools, DEFAULT_INTERACTION_DECISION_TIMEOUT_MS, InteractionBroker, type InteractionBrokerOptions, type InteractionQuestion, InteractionQuestionSchema, MAX_INTERACTION_DECISION_TIMEOUT_MS, type PermissionPromptBridge, type RequestPermissionBridge, type RequestPlanBridge, brokerInteractionTools, coercePermissionGrant, interactionAnswerSpecForQuestions, interactionDataToQuestionAnswers };
 //# sourceMappingURL=index.d.ts.map

package/dist/interactions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/interactions/http-bridge.ts"],"mappings":";;;;;;;;;cAsCa;WACF;mBACQ;mBACA;mBACA;mBACA;mBACA;UACT;UACA;EAER,YACE,QAAQ,mBACR;IACE;IACA,SAAS;IACT;IACA,QAAQ,OAAO;;MAUf;MAIA;EAIE,SAAS;EAgET,QAAQ;UAUA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/interactions/http-bridge.ts"],"mappings":";;;;;;;;;qBAsCa;WACF;mBACQ;mBACA;mBACA;mBACA;mBACA;UACT;UACA;EAER,YACE,QAAQ,mBACR;IACE;IACA,SAAS;IACT;IACA,QAAQ,OAAO;;MAUf;MAIA;EAIE,SAAS;EAgET,QAAQ;UAUA"}

package/dist/interactions/mcp-server.d.ts

@@ -1,9 +1,9 @@
 import { a as RequestPlanBridge, i as RequestPermissionBridge, r as PermissionPromptBridge, t as AskUserBridge } from "../tools-DeZkIW3h.js";
 //#region src/interactions/mcp-server.d.ts
-declare const DEFAULT_INTERACTION_MCP_SERVER_NAME = "tangle-interaction";
+export declare const DEFAULT_INTERACTION_MCP_SERVER_NAME = "tangle-interaction";
 /** Build the full tool name that a runner uses for an MCP tool. */
-declare function interactionMcpToolName(serverName: string, tool: string): string;
-interface InteractionMcpServerConfig {
+export declare function interactionMcpToolName(serverName: string, tool: string): string;
+export interface InteractionMcpServerConfig {
   serverName?: string;
   onStop: () => void | Promise<void>;
   permission?: PermissionPromptBridge;
@@ -16,7 +16,7 @@ interface InteractionMcpServerConfig {
  *
  * The server listens only on 127.0.0.1 and requires an ephemeral bearer token.
  */
-declare class InteractionMcpServer {
+export declare class InteractionMcpServer {
   private readonly server;
   private readonly transport;
   private readonly onStop;
@@ -37,5 +37,4 @@ declare class InteractionMcpServer {
   private requestGenerationId;
 }
 //#endregion
-export { DEFAULT_INTERACTION_MCP_SERVER_NAME, InteractionMcpServer, InteractionMcpServerConfig, interactionMcpToolName };
 //# sourceMappingURL=mcp-server.d.ts.map

package/dist/interactions/mcp-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","names":[],"sources":["../../src/interactions/mcp-server.ts"],"mappings":";;cA6Ba;;iBAqMG,uBACd,oBACA;UAKe;EACf;EACA,qBAAqB;EACrB,aAAa;EACb,UAAU;EACV,oBAAoB;EACpB,cAAc;;;;;;;cA+BH;mBACM;mBACA;mBACA;mBACA;mBACA;mBACA;UACT;UACA;WACC;WACA;EAET,YAAY,QAAQ;MAiJhB;MAIA;EAIE,SAAS;EAiGT,QAAQ;UAYN;UAOA;UAcA"}
+{"version":3,"file":"mcp-server.d.ts","names":[],"sources":["../../src/interactions/mcp-server.ts"],"mappings":";;qBA6Ba;;wBAqMG,uBACd,oBACA;iBAKe;EACf;EACA,qBAAqB;EACrB,aAAa;EACb,UAAU;EACV,oBAAoB;EACpB,cAAc;;;;;;;qBA+BH;mBACM;mBACA;mBACA;mBACA;mBACA;mBACA;UACT;UACA;WACC;WACA;EAET,YAAY,QAAQ;MAiJhB;MAIA;EAIE,SAAS;EAiGT,QAAQ;UAYN;UAOA;UAcA"}

package/dist/sse/index.d.ts

@@ -6,7 +6,7 @@
  * Used by sdk-telemetry, sdk-memory, and other consumers.
  */
 /** Raw SSE event data from stream */
-interface SSEEventData {
+export interface SSEEventData {
   type: string;
   toolName?: string;
   name?: string;
@@ -45,14 +45,14 @@ interface SSEEventData {
  * data: {"json": "payload"}
  * ```
  */
-declare function parseSSEData(rawData: string): SSEEventData | null;
-interface SSEParserOptions<T = unknown> {
+export declare function parseSSEData(rawData: string): SSEEventData | null;
+export interface SSEParserOptions<T = unknown> {
   /** Log malformed data lines (default: false) */
   logMalformed?: boolean;
   /** Custom data transformer */
   transform?: (raw: string) => T | null;
 }
-interface ParsedSSEEvent<T = unknown> {
+export interface ParsedSSEEvent<T = unknown> {
   data: T;
   rawData: string;
   eventId?: string;
@@ -62,7 +62,7 @@ interface ParsedSSEEvent<T = unknown> {
  * Incremental SSE parser for chunked streams.
  * Feed decoded string chunks via push(); call flush() on stream end.
  */
-declare class SSEChunkParser<T = unknown> {
+export declare class SSEChunkParser<T = unknown> {
   private buffer;
   private currentEvent;
   private options;
@@ -75,20 +75,20 @@ declare class SSEChunkParser<T = unknown> {
 /**
  * Parse SSE stream into typed events via async iteration.
  */
-declare function parseSSEStream<T = unknown>(stream: ReadableStream<Uint8Array>, options?: SSEParserOptions<T>): AsyncGenerator<ParsedSSEEvent<T>>;
+export declare function parseSSEStream<T = unknown>(stream: ReadableStream<Uint8Array>, options?: SSEParserOptions<T>): AsyncGenerator<ParsedSSEEvent<T>>;
 /**
  * Consume SSE stream with callbacks.
  */
-declare function consumeSSEStream<T = unknown>(stream: ReadableStream<Uint8Array>, onEvent: (event: ParsedSSEEvent<T>) => void, onError: (error: Error) => void, options?: SSEParserOptions<T>): Promise<void>;
+export declare function consumeSSEStream<T = unknown>(stream: ReadableStream<Uint8Array>, onEvent: (event: ParsedSSEEvent<T>) => void, onError: (error: Error) => void, options?: SSEParserOptions<T>): Promise<void>;
 /** Token usage extracted from stream */
-interface StreamTokenUsage {
+export interface StreamTokenUsage {
   inputTokens: number;
   outputTokens: number;
   cacheReadTokens?: number;
   cacheWriteTokens?: number;
 }
 /** Accumulated usage from a stream session */
-interface StreamUsageAccumulator {
+export interface StreamUsageAccumulator {
   /** Total tokens from all events */
   usage: StreamTokenUsage;
   /** Number of LLM response events */
@@ -119,7 +119,7 @@ interface StreamUsageAccumulator {
  * billingService.recordUsage({ usage: usage.usage, ... });
  * ```
  */
-declare class StreamUsageExtractor {
+export declare class StreamUsageExtractor {
   private accumulator;
   private finalized;
   constructor();
@@ -150,7 +150,7 @@ declare class StreamUsageExtractor {
 /**
  * Create a new StreamUsageExtractor.
  */
-declare function createStreamUsageExtractor(): StreamUsageExtractor;
+export declare function createStreamUsageExtractor(): StreamUsageExtractor;
 /**
  * Create a callback wrapper that extracts usage while forwarding events.
  *
@@ -164,11 +164,10 @@ declare function createStreamUsageExtractor(): StreamUsageExtractor;
  * const usage = getUsage();
  * ```
  */
-declare function createUsageCallback<T extends Record<string, unknown>>(forward?: (event: T) => void): {
+export declare function createUsageCallback<T extends Record<string, unknown>>(forward?: (event: T) => void): {
   callback: (event: T) => void;
   getUsage: () => StreamUsageAccumulator;
   extractor: StreamUsageExtractor;
 };
 //#endregion
-export { ParsedSSEEvent, SSEChunkParser, SSEEventData, SSEParserOptions, StreamTokenUsage, StreamUsageAccumulator, StreamUsageExtractor, consumeSSEStream, createStreamUsageExtractor, createUsageCallback, parseSSEData, parseSSEStream };
 //# sourceMappingURL=index.d.ts.map

package/dist/sse/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/sse/index.ts"],"mappings":";;;;;;;;UAQiB;EACf;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EAEA;EAEA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EAEA;IACE;IACA;IACA;IACA;;GAGD;;;;;;;;;;;iBAYa,aAAa,kBAAkB;UA+B9B,iBAAiB;;EAEhC;;EAEA,aAAa,gBAAgB;;UAGd,eAAe;EAC9B,MAAM;EACN;EACA;EACA;;;;;;cAOW,eAAe;UAClB;UACA;UACA;EAER,YAAY,UAAS,iBAAiB;EAItC,KAAK,gBAAgB,eAAe;EAOpC,SAAS,eAAe;UAYhB;UA4CA;;;;;iBA2Ca,eAAe,aACpC,QAAQ,eAAe,aACvB,UAAS,iBAAiB,KACzB,eAAe,eAAe;;;;iBA4CX,iBAAiB,aACrC,QAAQ,eAAe,aACvB,UAAU,OAAO,eAAe,aAChC,UAAU,OAAO,gBACjB,UAAS,iBAAiB,KACzB;;UAuCc;EACf;EACA;EACA;EACA;;;UAIe;;EAEf,OAAO;;EAEP;;EAEA;;EAEA;;EAEA,WAAW;;EAEX;;;;;;;;;;;;;;;;;;;cA0BW;UACH;UACA;EAER;;;;EAeA,cAAc;;;;EAUd,aAAa,OAAO,eAAe;;;;;EAoDnC,YAAY;;;;EAeZ,WAAW,SAAS;;;;EAOpB;UAaQ;UAyCA;;;;;iBA4BM,8BAA8B;;;;;;;;;;;;;;iBAiB9B,oBAAoB,UAAU,yBAC5C,WAAW,OAAO;EAElB,WAAW,OAAO;EAClB,gBAAgB;EAChB,WAAW"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/sse/index.ts"],"mappings":";;;;;;;;iBAQiB;EACf;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EAEA;EAEA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EAEA;IACE;IACA;IACA;IACA;;GAGD;;;;;;;;;;;wBAYa,aAAa,kBAAkB;iBA+B9B,iBAAiB;;EAEhC;;EAEA,aAAa,gBAAgB;;iBAGd,eAAe;EAC9B,MAAM;EACN;EACA;EACA;;;;;;qBAOW,eAAe;UAClB;UACA;UACA;EAER,YAAY,UAAS,iBAAiB;EAItC,KAAK,gBAAgB,eAAe;EAOpC,SAAS,eAAe;UAYhB;UA4CA;;;;;wBA2Ca,eAAe,aACpC,QAAQ,eAAe,aACvB,UAAS,iBAAiB,KACzB,eAAe,eAAe;;;;wBA4CX,iBAAiB,aACrC,QAAQ,eAAe,aACvB,UAAU,OAAO,eAAe,aAChC,UAAU,OAAO,gBACjB,UAAS,iBAAiB,KACzB;;iBAuCc;EACf;EACA;EACA;EACA;;;iBAIe;;EAEf,OAAO;;EAEP;;EAEA;;EAEA;;EAEA,WAAW;;EAEX;;;;;;;;;;;;;;;;;;;qBA0BW;UACH;UACA;EAER;;;;EAeA,cAAc;;;;EAUd,aAAa,OAAO,eAAe;;;;;EAoDnC,YAAY;;;;EAeZ,WAAW,SAAS;;;;EAOpB;UAaQ;UAyCA;;;;;wBA4BM,8BAA8B;;;;;;;;;;;;;;wBAiB9B,oBAAoB,UAAU,yBAC5C,WAAW,OAAO;EAElB,WAAW,OAAO;EAClB,gBAAgB;EAChB,WAAW"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-core",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "Core transport interfaces, event utilities, auth, SSE parsing, and resilience primitives for talking to Tangle agents",
   "type": "module",
   "license": "MIT",
@@ -138,9 +138,9 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@tangle-network/agent-interface": "^2.13.0",
-    "@tangle-network/agent-trace-contract": "^1.2.0",
-    "zod": "4.5.4"
+    "@tangle-network/agent-interface": "^2.13.1",
+    "@tangle-network/agent-trace-contract": "^2.0.0",
+    "zod": "4.6.5"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0"
@@ -151,11 +151,11 @@
     }
   },
   "devDependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@types/node": "26.4.1",
-    "tsdown": "0.22.14",
+    "@modelcontextprotocol/sdk": "^1.30.1",
+    "@types/node": "26.6.3",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.2"
   },
   "scripts": {
     "build": "tsdown",