@haaaiawd/second-nature 0.1.42 → 0.1.50

package/runtime/connectors/base/policy-layer.js

@@ -1,198 +0,0 @@
-import { classifyFailure } from "./failure-taxonomy.js";
-import { enforceExecutionPolicy } from "./execution-policy.js";
-const DEFAULT_RETRY_MAX = 3;
-const DEFAULT_BASE_DELAY_MS = 1000;
-const DEFAULT_MAX_DELAY_MS = 30000;
-function resolveRetryPolicy(input) {
-    return {
-        maxRetries: input?.maxRetries ?? DEFAULT_RETRY_MAX,
-        baseDelayMs: input?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS,
-        maxDelayMs: input?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS,
-        jitter: input?.jitter ?? true,
-    };
-}
-function computeRetryDelayMs(attempt, policy, retryAfterMs) {
-    if (typeof retryAfterMs === "number" && retryAfterMs > 0) {
-        return retryAfterMs;
-    }
-    const base = Math.min(policy.baseDelayMs * 2 ** Math.max(0, attempt - 1), policy.maxDelayMs);
-    if (!policy.jitter)
-        return base;
-    return Math.floor(base * 0.8 + Math.random() * base * 0.4);
-}
-async function sleep(ms) {
-    if (ms <= 0)
-        return;
-    await new Promise((resolve) => setTimeout(resolve, ms));
-}
-function makeTraceId(request, plan) {
-    return `${request.platformId}:${request.intent}:${plan.channel}:${Date.now()}`;
-}
-function resolveIdentity(request) {
-    if (!request.decisionId || !request.intentId) {
-        throw new Error("connector_policy_missing_decision_or_intent_identity");
-    }
-    return {
-        decisionId: request.decisionId,
-        intentId: request.intentId,
-    };
-}
-function isDegradedChannel(channel) {
-    return channel === "cli" || channel === "skill" || channel === "browser";
-}
-function adaptProtocolErrors(error) {
-    if (!error || typeof error !== "object") {
-        return error;
-    }
-    const record = error;
-    const detail = typeof record.detail === "string" ? record.detail : "";
-    if (detail === "node_secret_required") {
-        return { code: "verification_required", detail };
-    }
-    if (detail === "bundle_required") {
-        return { code: "protocol_mismatch", detail };
-    }
-    if (detail === "asset_id mismatch") {
-        return { code: "protocol_mismatch", detail };
-    }
-    return error;
-}
-export function createConnectorPolicyLayer(ctx) {
-    const retryPolicy = resolveRetryPolicy(ctx.retryPolicy);
-    const allowDegradedFallback = ctx.allowDegradedFallback ?? (() => true);
-    return {
-        async executeWithPolicy(intent, request) {
-            if (ctx.cooldownPort) {
-                const cooldown = await ctx.cooldownPort.isBlocked(request.platformId, intent);
-                if (cooldown.blocked) {
-                    return {
-                        status: "terminal_failure",
-                        failureClass: "cooldown_blocked",
-                        retryAfterMs: cooldown.retryAfterMs,
-                        metadata: {
-                            platformId: request.platformId,
-                            channel: request.preferredChannel ?? "api_rest",
-                            latencyMs: 0,
-                        },
-                    };
-                }
-            }
-            const identity = resolveIdentity(request);
-            let plan;
-            try {
-                plan = await ctx.routePlanner.planRoute(intent, request);
-            }
-            catch (error) {
-                const failure = classifyFailure(error);
-                return {
-                    status: "terminal_failure",
-                    failureClass: failure.class,
-                    retryAfterMs: failure.retryAfterMs,
-                    metadata: {
-                        platformId: request.platformId,
-                        channel: request.preferredChannel ?? "api_rest",
-                        latencyMs: 0,
-                    },
-                };
-            }
-            if (isDegradedChannel(plan.channel) && !allowDegradedFallback(plan, request)) {
-                return {
-                    status: "terminal_failure",
-                    failureClass: "protocol_mismatch",
-                    metadata: {
-                        platformId: request.platformId,
-                        channel: plan.channel,
-                        latencyMs: 0,
-                        degraded: true,
-                    },
-                };
-            }
-            const policyGate = await enforceExecutionPolicy(plan, intent, request, {
-                effectCommitLedger: ctx.effectCommitLedger,
-            });
-            if (policyGate.skipAdapter && policyGate.existingOutcomeRef) {
-                return {
-                    status: "success",
-                    data: { replayedCommit: true, outcomeRef: policyGate.existingOutcomeRef },
-                    metadata: {
-                        platformId: request.platformId,
-                        channel: plan.channel,
-                        latencyMs: 0,
-                        degraded: plan.degraded,
-                    },
-                };
-            }
-            let lastFailure;
-            for (let attempt = 1; attempt <= retryPolicy.maxRetries; attempt += 1) {
-                const traceId = `${makeTraceId(request, plan)}:${attempt}`;
-                if (ctx.telemetry) {
-                    await ctx.telemetry.startAttempt({
-                        traceId,
-                        decisionId: identity.decisionId,
-                        intentId: identity.intentId,
-                        platformId: request.platformId,
-                        capability: request.intent,
-                        channel: plan.channel,
-                        retryPolicy: JSON.stringify(retryPolicy),
-                        idempotencyKey: request.idempotencyKey,
-                    });
-                }
-                const raw = await ctx.executionRunner.run(plan, request);
-                if (raw.success) {
-                    if (ctx.telemetry) {
-                        await ctx.telemetry.completeAttempt(traceId, "succeeded");
-                    }
-                    return {
-                        status: "success",
-                        data: raw.payload,
-                        metadata: {
-                            platformId: raw.platformId,
-                            channel: raw.channel,
-                            latencyMs: raw.latencyMs,
-                            degraded: raw.degraded,
-                        },
-                    };
-                }
-                const classified = classifyFailure(adaptProtocolErrors(raw.error));
-                lastFailure = {
-                    failureClass: classified.class,
-                    retryAfterMs: classified.retryAfterMs,
-                    channel: raw.channel,
-                };
-                if (ctx.telemetry) {
-                    await ctx.telemetry.completeAttempt(traceId, "failed", undefined, classified.class);
-                }
-                if (ctx.cooldownPort) {
-                    await ctx.cooldownPort.markFailure(request.platformId, intent, classified.class, classified.retryAfterMs);
-                }
-                const isRetryable = classified.retryable;
-                if (!isRetryable || attempt >= retryPolicy.maxRetries) {
-                    return {
-                        status: "terminal_failure",
-                        failureClass: classified.class,
-                        retryAfterMs: classified.retryAfterMs,
-                        metadata: {
-                            platformId: raw.platformId,
-                            channel: raw.channel,
-                            latencyMs: raw.latencyMs,
-                            degraded: raw.degraded,
-                        },
-                    };
-                }
-                const delay = computeRetryDelayMs(attempt, retryPolicy, classified.retryAfterMs);
-                await sleep(delay);
-            }
-            return {
-                status: "terminal_failure",
-                failureClass: lastFailure?.failureClass ?? "unknown_platform_change",
-                retryAfterMs: lastFailure?.retryAfterMs,
-                metadata: {
-                    platformId: request.platformId,
-                    channel: lastFailure?.channel ?? plan.channel,
-                    latencyMs: 0,
-                    degraded: isDegradedChannel(lastFailure?.channel ?? plan.channel),
-                },
-            };
-        },
-    };
-}

package/runtime/connectors/manifest/manifest-schema.d.ts

@@ -1,149 +0,0 @@
-import { z } from "zod";
-export declare const connectorRunnerKindSchema: z.ZodEnum<{
-    skill: "skill";
-    browser: "browser";
-    declarative_http: "declarative_http";
-    declarative_a2a: "declarative_a2a";
-    declarative_mcp: "declarative_mcp";
-    cli_descriptor: "cli_descriptor";
-    custom_adapter: "custom_adapter";
-}>;
-export type ConnectorRunnerKind = z.infer<typeof connectorRunnerKindSchema>;
-export declare const connectorTrustStatusSchema: z.ZodEnum<{
-    blocked: "blocked";
-    declarative_trusted: "declarative_trusted";
-    custom_adapter_pending_trust: "custom_adapter_pending_trust";
-    trusted_custom_adapter: "trusted_custom_adapter";
-}>;
-export type ConnectorTrustStatus = z.infer<typeof connectorTrustStatusSchema>;
-export declare const capabilityDeclarationSchema: z.ZodObject<{
-    id: z.ZodString;
-    channel: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    sourceRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    observedCount: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type ConnectorCapabilityDeclaration = z.infer<typeof capabilityDeclarationSchema>;
-export declare const runnerDeclarationSchema: z.ZodObject<{
-    kind: z.ZodEnum<{
-        skill: "skill";
-        browser: "browser";
-        declarative_http: "declarative_http";
-        declarative_a2a: "declarative_a2a";
-        declarative_mcp: "declarative_mcp";
-        cli_descriptor: "cli_descriptor";
-        custom_adapter: "custom_adapter";
-    }>;
-    entrypoint: z.ZodOptional<z.ZodString>;
-    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-export type ConnectorRunnerDeclaration = z.infer<typeof runnerDeclarationSchema>;
-export declare const credentialRequirementSchema: z.ZodObject<{
-    type: z.ZodString;
-    required: z.ZodDefault<z.ZodBoolean>;
-    description: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type CredentialRequirementDeclaration = z.infer<typeof credentialRequirementSchema>;
-export declare const sourceRefPolicySchema: z.ZodObject<{
-    minSourceRefs: z.ZodDefault<z.ZodNumber>;
-    rejectInlineSensitivePayload: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type SourceRefPolicyDeclaration = z.infer<typeof sourceRefPolicySchema>;
-export declare const trustDeclarationSchema: z.ZodObject<{
-    status: z.ZodOptional<z.ZodEnum<{
-        blocked: "blocked";
-        declarative_trusted: "declarative_trusted";
-        custom_adapter_pending_trust: "custom_adapter_pending_trust";
-        trusted_custom_adapter: "trusted_custom_adapter";
-    }>>;
-    override: z.ZodOptional<z.ZodBoolean>;
-    reason: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ConnectorTrustDeclaration = z.infer<typeof trustDeclarationSchema>;
-export declare const connectorManifestV6Schema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<"sn.connector.v1">;
-    platformId: z.ZodString;
-    displayName: z.ZodString;
-    family: z.ZodEnum<{
-        custom: "custom";
-        social_community: "social_community";
-        agent_network: "agent_network";
-        work_platform: "work_platform";
-    }>;
-    capabilities: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        channel: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        sourceRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        observedCount: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    runner: z.ZodObject<{
-        kind: z.ZodEnum<{
-            skill: "skill";
-            browser: "browser";
-            declarative_http: "declarative_http";
-            declarative_a2a: "declarative_a2a";
-            declarative_mcp: "declarative_mcp";
-            cli_descriptor: "cli_descriptor";
-            custom_adapter: "custom_adapter";
-        }>;
-        entrypoint: z.ZodOptional<z.ZodString>;
-        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>;
-    credentials: z.ZodArray<z.ZodObject<{
-        type: z.ZodString;
-        required: z.ZodDefault<z.ZodBoolean>;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    sourceRefPolicy: z.ZodObject<{
-        minSourceRefs: z.ZodDefault<z.ZodNumber>;
-        rejectInlineSensitivePayload: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
-    trust: z.ZodOptional<z.ZodObject<{
-        status: z.ZodOptional<z.ZodEnum<{
-            blocked: "blocked";
-            declarative_trusted: "declarative_trusted";
-            custom_adapter_pending_trust: "custom_adapter_pending_trust";
-            trusted_custom_adapter: "trusted_custom_adapter";
-        }>>;
-        override: z.ZodOptional<z.ZodBoolean>;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ConnectorManifestV6 = z.infer<typeof connectorManifestV6Schema>;
-export interface ConnectorConflict {
-    platformId: string;
-    existingSource: "built_in" | "workspace";
-    attemptedSource: "built_in" | "workspace";
-    reason: string;
-}
-export interface ConnectorManifestValidationError {
-    platformId?: string;
-    path: string;
-    message: string;
-}
-export interface ConnectorInventoryEntry {
-    platformId: string;
-    source: "built_in" | "workspace";
-    manifestPath?: string;
-    trustStatus: ConnectorTrustStatus;
-    executable: boolean;
-    capabilities: string[];
-    validationErrors: string[];
-    conflict?: ConnectorConflict;
-}
-export interface ConnectorReloadResult {
-    scanned: number;
-    registered: number;
-    skipped: number;
-    conflicts: ConnectorConflict[];
-    validationErrors: ConnectorManifestValidationError[];
-}
-export interface ConnectorRegistrySnapshot {
-    readonly entries: ReadonlyMap<string, ConnectorInventoryEntry>;
-    readonly builtInEntries: ReadonlyMap<string, ConnectorInventoryEntry>;
-    readonly dynamicEntries: ReadonlyMap<string, ConnectorInventoryEntry>;
-    readonly conflicts: readonly ConnectorConflict[];
-    readonly validationErrors: readonly ConnectorManifestValidationError[];
-    readonly createdAt: string;
-}

package/runtime/connectors/manifest/manifest-schema.js

@@ -1,53 +0,0 @@
-import { z } from "zod";
-export const connectorRunnerKindSchema = z.enum([
-    "declarative_http",
-    "declarative_a2a",
-    "declarative_mcp",
-    "cli_descriptor",
-    "custom_adapter",
-    "skill",
-    "browser",
-]);
-export const connectorTrustStatusSchema = z.enum([
-    "declarative_trusted",
-    "custom_adapter_pending_trust",
-    "trusted_custom_adapter",
-    "blocked",
-]);
-export const capabilityDeclarationSchema = z.object({
-    id: z.string().min(1),
-    channel: z.string().optional(),
-    description: z.string().optional(),
-    sourceRefs: z.array(z.string().min(1)).optional(),
-    observedCount: z.number().int().positive().optional(),
-});
-export const runnerDeclarationSchema = z.object({
-    kind: connectorRunnerKindSchema,
-    entrypoint: z.string().optional(),
-    config: z.record(z.string(), z.unknown()).optional(),
-});
-export const credentialRequirementSchema = z.object({
-    type: z.string().min(1),
-    required: z.boolean().default(true),
-    description: z.string().optional(),
-});
-export const sourceRefPolicySchema = z.object({
-    minSourceRefs: z.number().int().min(0).default(1),
-    rejectInlineSensitivePayload: z.boolean().optional(),
-});
-export const trustDeclarationSchema = z.object({
-    status: connectorTrustStatusSchema.optional(),
-    override: z.boolean().optional(),
-    reason: z.string().optional(),
-});
-export const connectorManifestV6Schema = z.object({
-    schemaVersion: z.literal("sn.connector.v1"),
-    platformId: z.string().min(1),
-    displayName: z.string().min(1),
-    family: z.enum(["social_community", "agent_network", "work_platform", "custom"]),
-    capabilities: z.array(capabilityDeclarationSchema).min(1),
-    runner: runnerDeclarationSchema,
-    credentials: z.array(credentialRequirementSchema),
-    sourceRefPolicy: sourceRefPolicySchema,
-    trust: trustDeclarationSchema.optional(),
-});

package/runtime/connectors/services/connector-executor-adapter.d.ts

@@ -1,17 +0,0 @@
-/**
- * Adapter: assemble connector-system execution infrastructure into the
- * ConnectorExecutor interface consumed by EffectDispatcher.
- *
- * When credentials / base URLs are missing, returns an honest
- * terminal_failure instead of throwing so the heartbeat loop stays stable.
- */
-import type { ConnectorExecutor } from "../base/contract.js";
-export type { ConnectorExecutor } from "../base/contract.js";
-import type { ObservabilityDatabase } from "../../observability/db/index.js";
-import type { StateDatabase } from "../../storage/db/index.js";
-export interface ConnectorExecutorAdapterOptions {
-    stateDb: StateDatabase;
-    observabilityDb: ObservabilityDatabase;
-    workspaceRoot?: string;
-}
-export declare function createConnectorExecutorAdapter(options: ConnectorExecutorAdapterOptions): ConnectorExecutor;