@haaaiawd/second-nature 0.1.43 → 0.1.51

package/runtime/connectors/base/contract.d.ts

@@ -1,111 +1,111 @@
-import type { CredentialContext, CredentialState } from "../../shared/types/credential.js";
-import { type FailureClass } from "./failure-taxonomy.js";
-export declare const CHANNEL_TYPES: readonly ["api_rest", "api_rpc", "a2a", "mcp", "cli", "skill", "browser"];
-export type ChannelType = (typeof CHANNEL_TYPES)[number];
-export declare const CAPABILITY_INTENTS: readonly ["feed.read", "post.publish", "comment.reply", "notification.list", "message.send", "agent.register", "agent.heartbeat", "work.discover", "task.claim"];
-export type BuiltInCapabilityIntent = (typeof CAPABILITY_INTENTS)[number];
-export type CapabilityIntent = BuiltInCapabilityIntent | (string & {});
-export declare function isKnownCapabilityIntent(intent: string): intent is BuiltInCapabilityIntent;
-export interface ConnectorRequestIdentity {
-    /** Platform handle for the target platform (readable, no credential). */
-    platformHandle?: string;
-    /** Canonical name across all platforms. */
-    canonicalName?: string;
-}
-export interface ConnectorRequest {
-    platformId: string;
-    intent: CapabilityIntent;
-    payload: Record<string, unknown>;
-    preferredChannel?: ChannelType;
-    timeoutMs?: number;
-    idempotencyKey?: string;
-    decisionId?: string;
-    intentId?: string;
-    /** T-V7C.C.4: identity for connector request (readable, no credential). */
-    identity?: ConnectorRequestIdentity;
-}
-export interface ExecutionPlan {
-    platformId: string;
-    intent: CapabilityIntent;
-    channel: ChannelType;
-    endpointMode: "rest_json" | "a2a_envelope" | "cli_stdout" | "skill_call";
-    idempotencyKey?: string;
-    /** True when selected channel is manifest-marked degraded (cli/skill/browser). */
-    degraded?: boolean;
-}
-export interface ConnectorResult<T> {
-    status: "success" | "retryable_failure" | "terminal_failure";
-    data?: T;
-    failureClass?: FailureClass;
-    retryAfterMs?: number;
-    executionId?: string;
-    metadata: {
-        platformId: string;
-        channel: ChannelType;
-        latencyMs: number;
-        degraded?: boolean;
-        detail?: string;
-    };
-}
-export interface RawAttempt {
-    platformId: string;
-    channel: ChannelType;
-    latencyMs: number;
-    degraded?: boolean;
-    success: boolean;
-    payload?: unknown;
-    error?: unknown;
-}
-export interface CredentialContextPort {
-    loadCredentialState(platformId: string): Promise<CredentialContext>;
-}
-export interface CooldownLedgerPort {
-    loadCooldownState(platformId: string, intent: CapabilityIntent): Promise<{
-        blocked: boolean;
-        retryAfterMs?: number;
-    }>;
-}
-export interface RouteContextPort extends CredentialContextPort, CooldownLedgerPort {
-}
-export interface ConnectorManifestLike {
-    platformId: string;
-    supportedCapabilities: CapabilityIntent[];
-    channelPriority: ChannelType[];
-    credentialTypes: string[];
-    degradedChannels?: ChannelType[];
-    sourceRefPolicy?: {
-        minSourceRefs?: number;
-        rejectInlineSensitivePayload?: boolean;
-    };
-}
-export interface ConnectorManifestLoader {
-    loadManifest(platformId: string): ConnectorManifestLike;
-}
-export interface RoutePlanner {
-    planRoute(intent: CapabilityIntent, request: ConnectorRequest): Promise<ExecutionPlan>;
-}
-export interface ExecutionRunner {
-    run(plan: ExecutionPlan, request: ConnectorRequest): Promise<RawAttempt>;
-}
-export interface ConnectorExecutionPort {
-    executeCapability(intent: CapabilityIntent, request: ConnectorRequest): Promise<ConnectorResult<unknown>>;
-}
-export interface ConnectorExecutor {
-    executeEffect(input: {
-        platformId: string;
-        intent: CapabilityIntent;
-        payload: Record<string, unknown>;
-        decisionId: string;
-        intentId: string;
-        idempotencyKey: string;
-        /** T-V7C.C.4: identity for connector request (readable, no credential). */
-        identity?: ConnectorRequestIdentity;
-    }): Promise<ConnectorResult<unknown>>;
-}
-export declare function normalizeOutcome(attempt: RawAttempt): ConnectorResult<unknown>;
-export declare function createConnectorContractCore(input: {
-    manifestLoader: ConnectorManifestLoader;
-    routePlanner: RoutePlanner;
-    executionRunner: ExecutionRunner;
-}): ConnectorExecutionPort;
-export declare function isCredentialActive(state: CredentialState): boolean;
+import type { CredentialContext, CredentialState } from "../../shared/types/credential.js";
+import { type FailureClass } from "./failure-taxonomy.js";
+export declare const CHANNEL_TYPES: readonly ["api_rest", "api_rpc", "a2a", "mcp", "cli", "skill", "browser"];
+export type ChannelType = (typeof CHANNEL_TYPES)[number];
+export declare const CAPABILITY_INTENTS: readonly ["feed.read", "post.publish", "comment.reply", "notification.list", "message.send", "agent.register", "agent.heartbeat", "work.discover", "task.claim"];
+export type BuiltInCapabilityIntent = (typeof CAPABILITY_INTENTS)[number];
+export type CapabilityIntent = BuiltInCapabilityIntent | (string & {});
+export declare function isKnownCapabilityIntent(intent: string): intent is BuiltInCapabilityIntent;
+export interface ConnectorRequestIdentity {
+    /** Platform handle for the target platform (readable, no credential). */
+    platformHandle?: string;
+    /** Canonical name across all platforms. */
+    canonicalName?: string;
+}
+export interface ConnectorRequest {
+    platformId: string;
+    intent: CapabilityIntent;
+    payload: Record<string, unknown>;
+    preferredChannel?: ChannelType;
+    timeoutMs?: number;
+    idempotencyKey?: string;
+    decisionId?: string;
+    intentId?: string;
+    /** T-V7C.C.4: identity for connector request (readable, no credential). */
+    identity?: ConnectorRequestIdentity;
+}
+export interface ExecutionPlan {
+    platformId: string;
+    intent: CapabilityIntent;
+    channel: ChannelType;
+    endpointMode: "rest_json" | "a2a_envelope" | "cli_stdout" | "skill_call";
+    idempotencyKey?: string;
+    /** True when selected channel is manifest-marked degraded (cli/skill/browser). */
+    degraded?: boolean;
+}
+export interface ConnectorResult<T> {
+    status: "success" | "retryable_failure" | "terminal_failure";
+    data?: T;
+    failureClass?: FailureClass;
+    retryAfterMs?: number;
+    executionId?: string;
+    metadata: {
+        platformId: string;
+        channel: ChannelType;
+        latencyMs: number;
+        degraded?: boolean;
+        detail?: string;
+    };
+}
+export interface RawAttempt {
+    platformId: string;
+    channel: ChannelType;
+    latencyMs: number;
+    degraded?: boolean;
+    success: boolean;
+    payload?: unknown;
+    error?: unknown;
+}
+export interface CredentialContextPort {
+    loadCredentialState(platformId: string): Promise<CredentialContext>;
+}
+export interface CooldownLedgerPort {
+    loadCooldownState(platformId: string, intent: CapabilityIntent): Promise<{
+        blocked: boolean;
+        retryAfterMs?: number;
+    }>;
+}
+export interface RouteContextPort extends CredentialContextPort, CooldownLedgerPort {
+}
+export interface ConnectorManifestLike {
+    platformId: string;
+    supportedCapabilities: CapabilityIntent[];
+    channelPriority: ChannelType[];
+    credentialTypes: string[];
+    degradedChannels?: ChannelType[];
+    sourceRefPolicy?: {
+        minSourceRefs?: number;
+        rejectInlineSensitivePayload?: boolean;
+    };
+}
+export interface ConnectorManifestLoader {
+    loadManifest(platformId: string): ConnectorManifestLike;
+}
+export interface RoutePlanner {
+    planRoute(intent: CapabilityIntent, request: ConnectorRequest): Promise<ExecutionPlan>;
+}
+export interface ExecutionRunner {
+    run(plan: ExecutionPlan, request: ConnectorRequest): Promise<RawAttempt>;
+}
+export interface ConnectorExecutionPort {
+    executeCapability(intent: CapabilityIntent, request: ConnectorRequest): Promise<ConnectorResult<unknown>>;
+}
+export interface ConnectorExecutor {
+    executeEffect(input: {
+        platformId: string;
+        intent: CapabilityIntent;
+        payload: Record<string, unknown>;
+        decisionId: string;
+        intentId: string;
+        idempotencyKey: string;
+        /** T-V7C.C.4: identity for connector request (readable, no credential). */
+        identity?: ConnectorRequestIdentity;
+    }): Promise<ConnectorResult<unknown>>;
+}
+export declare function normalizeOutcome(attempt: RawAttempt): ConnectorResult<unknown>;
+export declare function createConnectorContractCore(input: {
+    manifestLoader: ConnectorManifestLoader;
+    routePlanner: RoutePlanner;
+    executionRunner: ExecutionRunner;
+}): ConnectorExecutionPort;
+export declare function isCredentialActive(state: CredentialState): boolean;

package/runtime/connectors/base/failure-taxonomy.d.ts

@@ -1,13 +1,13 @@
-export declare const FAILURE_CLASSES: readonly ["transport_failure", "auth_failure", "credential_expired", "verification_required", "rate_limited", "cooldown_blocked", "parse_failure", "protocol_mismatch", "semantic_rejection", "idempotency_conflict", "concurrency_conflict", "permanent_input_error", "platform_unavailable", "configuration_missing", "script_error", "timeout", "unknown_platform_change"];
-export type FailureClass = (typeof FAILURE_CLASSES)[number];
-export interface FailureClassification {
-    class: FailureClass;
-    retryable: boolean;
-    retryAfterMs?: number;
-}
-export declare class ConnectorPolicyError extends Error {
-    readonly failureClass: FailureClass;
-    readonly retryAfterMs?: number | undefined;
-    constructor(failureClass: FailureClass, message: string, retryAfterMs?: number | undefined);
-}
-export declare function classifyFailure(error: unknown): FailureClassification;
+export declare const FAILURE_CLASSES: readonly ["transport_failure", "auth_failure", "credential_expired", "verification_required", "rate_limited", "cooldown_blocked", "parse_failure", "protocol_mismatch", "semantic_rejection", "idempotency_conflict", "concurrency_conflict", "permanent_input_error", "platform_unavailable", "configuration_missing", "script_error", "timeout", "unknown_platform_change"];
+export type FailureClass = (typeof FAILURE_CLASSES)[number];
+export interface FailureClassification {
+    class: FailureClass;
+    retryable: boolean;
+    retryAfterMs?: number;
+}
+export declare class ConnectorPolicyError extends Error {
+    readonly failureClass: FailureClass;
+    readonly retryAfterMs?: number | undefined;
+    constructor(failureClass: FailureClass, message: string, retryAfterMs?: number | undefined);
+}
+export declare function classifyFailure(error: unknown): FailureClassification;

package/runtime/connectors/base/failure-taxonomy.js

@@ -1,186 +1,186 @@
-export const FAILURE_CLASSES = [
-    "transport_failure",
-    "auth_failure",
-    "credential_expired",
-    "verification_required",
-    "rate_limited",
-    "cooldown_blocked",
-    "parse_failure",
-    "protocol_mismatch",
-    "semantic_rejection",
-    "idempotency_conflict",
-    "concurrency_conflict",
-    "permanent_input_error",
-    "platform_unavailable",
-    "configuration_missing",
-    "script_error",
-    "timeout",
-    "unknown_platform_change",
-];
-const RETRYABLE_BY_CLASS = {
-    transport_failure: true,
-    auth_failure: false,
-    credential_expired: false,
-    verification_required: false,
-    rate_limited: true,
-    cooldown_blocked: false,
-    parse_failure: false,
-    protocol_mismatch: false,
-    semantic_rejection: false,
-    idempotency_conflict: false,
-    concurrency_conflict: true,
-    permanent_input_error: false,
-    platform_unavailable: false,
-    configuration_missing: false,
-    script_error: false,
-    timeout: true,
-    unknown_platform_change: false,
-};
-export class ConnectorPolicyError extends Error {
-    failureClass;
-    retryAfterMs;
-    constructor(failureClass, message, retryAfterMs) {
-        super(message);
-        this.failureClass = failureClass;
-        this.retryAfterMs = retryAfterMs;
-        this.name = "ConnectorPolicyError";
-    }
-}
-function readRetryAfterMs(input) {
-    const retryAfterMs = input.retryAfterMs;
-    if (typeof retryAfterMs === "number" &&
-        Number.isFinite(retryAfterMs) &&
-        retryAfterMs > 0) {
-        return retryAfterMs;
-    }
-    const retryAfterSeconds = input.retryAfterSeconds;
-    if (typeof retryAfterSeconds === "number" &&
-        Number.isFinite(retryAfterSeconds) &&
-        retryAfterSeconds > 0) {
-        return retryAfterSeconds * 1000;
-    }
-    return undefined;
-}
-export function classifyFailure(error) {
-    if (error instanceof ConnectorPolicyError) {
-        return {
-            class: error.failureClass,
-            retryable: RETRYABLE_BY_CLASS[error.failureClass],
-            retryAfterMs: error.retryAfterMs,
-        };
-    }
-    if (error instanceof SyntaxError) {
-        return { class: "parse_failure", retryable: false };
-    }
-    if (error && typeof error === "object") {
-        const record = error;
-        const code = record.code;
-        if (typeof code === "string") {
-            if (code === "auth_failure")
-                return {
-                    class: "auth_failure",
-                    retryable: RETRYABLE_BY_CLASS.auth_failure,
-                };
-            if (code === "verification_required")
-                return {
-                    class: "verification_required",
-                    retryable: RETRYABLE_BY_CLASS.verification_required,
-                };
-            if (code === "credential_expired")
-                return {
-                    class: "credential_expired",
-                    retryable: RETRYABLE_BY_CLASS.credential_expired,
-                };
-            if (code === "cooldown_blocked")
-                return {
-                    class: "cooldown_blocked",
-                    retryable: RETRYABLE_BY_CLASS.cooldown_blocked,
-                };
-            if (code === "idempotency_conflict")
-                return {
-                    class: "idempotency_conflict",
-                    retryable: RETRYABLE_BY_CLASS.idempotency_conflict,
-                };
-            if (code === "concurrency_conflict")
-                return {
-                    class: "concurrency_conflict",
-                    retryable: RETRYABLE_BY_CLASS.concurrency_conflict,
-                };
-            if (code === "protocol_mismatch")
-                return {
-                    class: "protocol_mismatch",
-                    retryable: RETRYABLE_BY_CLASS.protocol_mismatch,
-                };
-            if (code === "semantic_rejection")
-                return {
-                    class: "semantic_rejection",
-                    retryable: RETRYABLE_BY_CLASS.semantic_rejection,
-                };
-            if (code === "transport_failure")
-                return {
-                    class: "transport_failure",
-                    retryable: RETRYABLE_BY_CLASS.transport_failure,
-                };
-            if (code === "permanent_input_error")
-                return {
-                    class: "permanent_input_error",
-                    retryable: RETRYABLE_BY_CLASS.permanent_input_error,
-                };
-            if (code === "platform_unavailable")
-                return {
-                    class: "platform_unavailable",
-                    retryable: RETRYABLE_BY_CLASS.platform_unavailable,
-                };
-            if (code === "configuration_missing")
-                return {
-                    class: "configuration_missing",
-                    retryable: RETRYABLE_BY_CLASS.configuration_missing,
-                };
-            if (code === "script_error")
-                return {
-                    class: "script_error",
-                    retryable: RETRYABLE_BY_CLASS.script_error,
-                };
-            if (code === "timeout")
-                return {
-                    class: "timeout",
-                    retryable: RETRYABLE_BY_CLASS.timeout,
-                };
-            if (code === "unknown_platform" || code === "unknown_platform_change")
-                return {
-                    class: "unknown_platform_change",
-                    retryable: RETRYABLE_BY_CLASS.unknown_platform_change,
-                };
-        }
-        const status = record.status;
-        if (status === 429) {
-            return {
-                class: "rate_limited",
-                retryable: RETRYABLE_BY_CLASS.rate_limited,
-                retryAfterMs: readRetryAfterMs(record),
-            };
-        }
-        if (status === 401 || status === 403) {
-            return {
-                class: "auth_failure",
-                retryable: RETRYABLE_BY_CLASS.auth_failure,
-            };
-        }
-        if (status === 400 || status === 404 || status === 422) {
-            return {
-                class: "permanent_input_error",
-                retryable: RETRYABLE_BY_CLASS.permanent_input_error,
-            };
-        }
-        if (status === 500 || status === 502 || status === 503 || status === 504) {
-            return {
-                class: "transport_failure",
-                retryable: RETRYABLE_BY_CLASS.transport_failure,
-            };
-        }
-    }
-    return {
-        class: "unknown_platform_change",
-        retryable: RETRYABLE_BY_CLASS.unknown_platform_change,
-    };
-}
+export const FAILURE_CLASSES = [
+    "transport_failure",
+    "auth_failure",
+    "credential_expired",
+    "verification_required",
+    "rate_limited",
+    "cooldown_blocked",
+    "parse_failure",
+    "protocol_mismatch",
+    "semantic_rejection",
+    "idempotency_conflict",
+    "concurrency_conflict",
+    "permanent_input_error",
+    "platform_unavailable",
+    "configuration_missing",
+    "script_error",
+    "timeout",
+    "unknown_platform_change",
+];
+const RETRYABLE_BY_CLASS = {
+    transport_failure: true,
+    auth_failure: false,
+    credential_expired: false,
+    verification_required: false,
+    rate_limited: true,
+    cooldown_blocked: false,
+    parse_failure: false,
+    protocol_mismatch: false,
+    semantic_rejection: false,
+    idempotency_conflict: false,
+    concurrency_conflict: true,
+    permanent_input_error: false,
+    platform_unavailable: false,
+    configuration_missing: false,
+    script_error: false,
+    timeout: true,
+    unknown_platform_change: false,
+};
+export class ConnectorPolicyError extends Error {
+    failureClass;
+    retryAfterMs;
+    constructor(failureClass, message, retryAfterMs) {
+        super(message);
+        this.failureClass = failureClass;
+        this.retryAfterMs = retryAfterMs;
+        this.name = "ConnectorPolicyError";
+    }
+}
+function readRetryAfterMs(input) {
+    const retryAfterMs = input.retryAfterMs;
+    if (typeof retryAfterMs === "number" &&
+        Number.isFinite(retryAfterMs) &&
+        retryAfterMs > 0) {
+        return retryAfterMs;
+    }
+    const retryAfterSeconds = input.retryAfterSeconds;
+    if (typeof retryAfterSeconds === "number" &&
+        Number.isFinite(retryAfterSeconds) &&
+        retryAfterSeconds > 0) {
+        return retryAfterSeconds * 1000;
+    }
+    return undefined;
+}
+export function classifyFailure(error) {
+    if (error instanceof ConnectorPolicyError) {
+        return {
+            class: error.failureClass,
+            retryable: RETRYABLE_BY_CLASS[error.failureClass],
+            retryAfterMs: error.retryAfterMs,
+        };
+    }
+    if (error instanceof SyntaxError) {
+        return { class: "parse_failure", retryable: false };
+    }
+    if (error && typeof error === "object") {
+        const record = error;
+        const code = record.code;
+        if (typeof code === "string") {
+            if (code === "auth_failure")
+                return {
+                    class: "auth_failure",
+                    retryable: RETRYABLE_BY_CLASS.auth_failure,
+                };
+            if (code === "verification_required")
+                return {
+                    class: "verification_required",
+                    retryable: RETRYABLE_BY_CLASS.verification_required,
+                };
+            if (code === "credential_expired")
+                return {
+                    class: "credential_expired",
+                    retryable: RETRYABLE_BY_CLASS.credential_expired,
+                };
+            if (code === "cooldown_blocked")
+                return {
+                    class: "cooldown_blocked",
+                    retryable: RETRYABLE_BY_CLASS.cooldown_blocked,
+                };
+            if (code === "idempotency_conflict")
+                return {
+                    class: "idempotency_conflict",
+                    retryable: RETRYABLE_BY_CLASS.idempotency_conflict,
+                };
+            if (code === "concurrency_conflict")
+                return {
+                    class: "concurrency_conflict",
+                    retryable: RETRYABLE_BY_CLASS.concurrency_conflict,
+                };
+            if (code === "protocol_mismatch")
+                return {
+                    class: "protocol_mismatch",
+                    retryable: RETRYABLE_BY_CLASS.protocol_mismatch,
+                };
+            if (code === "semantic_rejection")
+                return {
+                    class: "semantic_rejection",
+                    retryable: RETRYABLE_BY_CLASS.semantic_rejection,
+                };
+            if (code === "transport_failure")
+                return {
+                    class: "transport_failure",
+                    retryable: RETRYABLE_BY_CLASS.transport_failure,
+                };
+            if (code === "permanent_input_error")
+                return {
+                    class: "permanent_input_error",
+                    retryable: RETRYABLE_BY_CLASS.permanent_input_error,
+                };
+            if (code === "platform_unavailable")
+                return {
+                    class: "platform_unavailable",
+                    retryable: RETRYABLE_BY_CLASS.platform_unavailable,
+                };
+            if (code === "configuration_missing")
+                return {
+                    class: "configuration_missing",
+                    retryable: RETRYABLE_BY_CLASS.configuration_missing,
+                };
+            if (code === "script_error")
+                return {
+                    class: "script_error",
+                    retryable: RETRYABLE_BY_CLASS.script_error,
+                };
+            if (code === "timeout")
+                return {
+                    class: "timeout",
+                    retryable: RETRYABLE_BY_CLASS.timeout,
+                };
+            if (code === "unknown_platform" || code === "unknown_platform_change")
+                return {
+                    class: "unknown_platform_change",
+                    retryable: RETRYABLE_BY_CLASS.unknown_platform_change,
+                };
+        }
+        const status = record.status;
+        if (status === 429) {
+            return {
+                class: "rate_limited",
+                retryable: RETRYABLE_BY_CLASS.rate_limited,
+                retryAfterMs: readRetryAfterMs(record),
+            };
+        }
+        if (status === 401 || status === 403) {
+            return {
+                class: "auth_failure",
+                retryable: RETRYABLE_BY_CLASS.auth_failure,
+            };
+        }
+        if (status === 400 || status === 404 || status === 422) {
+            return {
+                class: "permanent_input_error",
+                retryable: RETRYABLE_BY_CLASS.permanent_input_error,
+            };
+        }
+        if (status === 500 || status === 502 || status === 503 || status === 504) {
+            return {
+                class: "transport_failure",
+                retryable: RETRYABLE_BY_CLASS.transport_failure,
+            };
+        }
+    }
+    return {
+        class: "unknown_platform_change",
+        retryable: RETRYABLE_BY_CLASS.unknown_platform_change,
+    };
+}