@haaaiawd/second-nature 0.1.18 → 0.1.20

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

@@ -1,198 +1,198 @@
-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),
-                },
-            };
-        },
-    };
-}
+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/base/route-planner.js

@@ -1,99 +1,99 @@
-import { ConnectorPolicyError } from "./failure-taxonomy.js";
-const HIGH_RISK_SIDE_EFFECTS = new Set([
-    "post.publish",
-    "comment.reply",
-    "message.send",
-    "task.claim",
-]);
-function endpointModeFor(channel) {
-    if (channel === "a2a")
-        return "a2a_envelope";
-    if (channel === "cli")
-        return "cli_stdout";
-    if (channel === "skill" || channel === "browser")
-        return "skill_call";
-    return "rest_json";
-}
-const DEFAULT_DEGRADED_CHANNELS = ["cli", "skill", "browser"];
-function isDegradedChannel(channel, degradedChannels) {
-    const policy = degradedChannels && degradedChannels.length > 0 ? degradedChannels : DEFAULT_DEGRADED_CHANNELS;
-    return policy.includes(channel);
-}
-function chooseByCredentialState(channels, credential) {
-    if (credential.status === "pending_verification") {
-        if (channels.includes("skill"))
-            return "skill";
-        if (channels.includes("browser"))
-            return "browser";
-        throw new ConnectorPolicyError("verification_required", "verification_recovery_channel_missing");
-    }
-    return undefined;
-}
-function choosePreferred(channels, preferred) {
-    if (preferred && channels.includes(preferred))
-        return preferred;
-    return undefined;
-}
-function chooseHealthy(channels, platformId, health) {
-    for (const channel of channels) {
-        const snapshot = health.get(platformId, channel);
-        if (!snapshot)
-            return channel;
-        if (snapshot.healthy && !snapshot.degraded)
-            return channel;
-        if (snapshot.healthy)
-            return channel;
-    }
-    return channels[0];
-}
-function enforceSideEffectSafety(intent, channel, degradedChannels) {
-    if (!HIGH_RISK_SIDE_EFFECTS.has(intent)) {
-        return;
-    }
-    if (isDegradedChannel(channel, degradedChannels)) {
-        throw new ConnectorPolicyError("protocol_mismatch", "degraded_channel_not_allowed_for_side_effect");
-    }
-}
-export class ConnectorRoutePlanner {
-    registry;
-    statePort;
-    channelHealth;
-    constructor(registry, statePort, channelHealth) {
-        this.registry = registry;
-        this.statePort = statePort;
-        this.channelHealth = channelHealth;
-    }
-    async planRoute(intent, request) {
-        const manifest = this.registry.loadManifest(request.platformId);
-        if (!manifest.supportedCapabilities.includes(intent)) {
-            throw new ConnectorPolicyError("protocol_mismatch", "capability_not_supported_by_manifest");
-        }
-        const cooldown = await this.statePort.loadCooldownState(request.platformId, intent);
-        if (cooldown.blocked) {
-            throw new ConnectorPolicyError("cooldown_blocked", "platform_or_intent_cooldown_blocked", cooldown.retryAfterMs);
-        }
-        const credential = await this.statePort.loadCredentialState(request.platformId);
-        if (credential.status === "missing" || credential.status === "revoked" || credential.status === "failed") {
-            throw new ConnectorPolicyError("auth_failure", "credential_unavailable_for_route");
-        }
-        if (credential.status === "expired") {
-            throw new ConnectorPolicyError("credential_expired", "credential_expired_for_route");
-        }
-        const channels = [...manifest.channelPriority];
-        const byCredential = chooseByCredentialState(channels, credential);
-        const preferred = choosePreferred(channels, request.preferredChannel);
-        const selected = byCredential ?? preferred ?? chooseHealthy(channels, request.platformId, this.channelHealth);
-        if (!selected) {
-            throw new ConnectorPolicyError("protocol_mismatch", "no_available_channel");
-        }
-        enforceSideEffectSafety(intent, selected, manifest.degradedChannels);
-        return {
-            platformId: request.platformId,
-            intent,
-            channel: selected,
-            endpointMode: endpointModeFor(selected),
-            idempotencyKey: request.idempotencyKey,
-            degraded: isDegradedChannel(selected, manifest.degradedChannels),
-        };
-    }
-}
+import { ConnectorPolicyError } from "./failure-taxonomy.js";
+const HIGH_RISK_SIDE_EFFECTS = new Set([
+    "post.publish",
+    "comment.reply",
+    "message.send",
+    "task.claim",
+]);
+function endpointModeFor(channel) {
+    if (channel === "a2a")
+        return "a2a_envelope";
+    if (channel === "cli")
+        return "cli_stdout";
+    if (channel === "skill" || channel === "browser")
+        return "skill_call";
+    return "rest_json";
+}
+const DEFAULT_DEGRADED_CHANNELS = ["cli", "skill", "browser"];
+function isDegradedChannel(channel, degradedChannels) {
+    const policy = degradedChannels && degradedChannels.length > 0 ? degradedChannels : DEFAULT_DEGRADED_CHANNELS;
+    return policy.includes(channel);
+}
+function chooseByCredentialState(channels, credential) {
+    if (credential.status === "pending_verification") {
+        if (channels.includes("skill"))
+            return "skill";
+        if (channels.includes("browser"))
+            return "browser";
+        throw new ConnectorPolicyError("verification_required", "verification_recovery_channel_missing");
+    }
+    return undefined;
+}
+function choosePreferred(channels, preferred) {
+    if (preferred && channels.includes(preferred))
+        return preferred;
+    return undefined;
+}
+function chooseHealthy(channels, platformId, health) {
+    for (const channel of channels) {
+        const snapshot = health.get(platformId, channel);
+        if (!snapshot)
+            return channel;
+        if (snapshot.healthy && !snapshot.degraded)
+            return channel;
+        if (snapshot.healthy)
+            return channel;
+    }
+    return channels[0];
+}
+function enforceSideEffectSafety(intent, channel, degradedChannels) {
+    if (!HIGH_RISK_SIDE_EFFECTS.has(intent)) {
+        return;
+    }
+    if (isDegradedChannel(channel, degradedChannels)) {
+        throw new ConnectorPolicyError("protocol_mismatch", "degraded_channel_not_allowed_for_side_effect");
+    }
+}
+export class ConnectorRoutePlanner {
+    registry;
+    statePort;
+    channelHealth;
+    constructor(registry, statePort, channelHealth) {
+        this.registry = registry;
+        this.statePort = statePort;
+        this.channelHealth = channelHealth;
+    }
+    async planRoute(intent, request) {
+        const manifest = this.registry.loadManifest(request.platformId);
+        if (!manifest.supportedCapabilities.includes(intent)) {
+            throw new ConnectorPolicyError("protocol_mismatch", "capability_not_supported_by_manifest");
+        }
+        const cooldown = await this.statePort.loadCooldownState(request.platformId, intent);
+        if (cooldown.blocked) {
+            throw new ConnectorPolicyError("cooldown_blocked", "platform_or_intent_cooldown_blocked", cooldown.retryAfterMs);
+        }
+        const credential = await this.statePort.loadCredentialState(request.platformId);
+        if (credential.status === "missing" || credential.status === "revoked" || credential.status === "failed") {
+            throw new ConnectorPolicyError("auth_failure", "credential_unavailable_for_route");
+        }
+        if (credential.status === "expired") {
+            throw new ConnectorPolicyError("credential_expired", "credential_expired_for_route");
+        }
+        const channels = [...manifest.channelPriority];
+        const byCredential = chooseByCredentialState(channels, credential);
+        const preferred = choosePreferred(channels, request.preferredChannel);
+        const selected = byCredential ?? preferred ?? chooseHealthy(channels, request.platformId, this.channelHealth);
+        if (!selected) {
+            throw new ConnectorPolicyError("protocol_mismatch", "no_available_channel");
+        }
+        enforceSideEffectSafety(intent, selected, manifest.degradedChannels);
+        return {
+            platformId: request.platformId,
+            intent,
+            channel: selected,
+            endpointMode: endpointModeFor(selected),
+            idempotencyKey: request.idempotencyKey,
+            degraded: isDegradedChannel(selected, manifest.degradedChannels),
+        };
+    }
+}

package/runtime/connectors/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./base/index.js";
-export * from "./social-community/moltbook/index.js";
-export * from "./social-community/instreet/index.js";
-export * from "./agent-network/evomap/index.js";
-export * from "./near-real/near-real-connector-smoke.js";
+export * from "./base/index.js";
+export * from "./social-community/moltbook/index.js";
+export * from "./social-community/instreet/index.js";
+export * from "./agent-network/evomap/index.js";
+export * from "./near-real/near-real-connector-smoke.js";

package/runtime/connectors/index.js

@@ -1,5 +1,5 @@
-export * from "./base/index.js";
-export * from "./social-community/moltbook/index.js";
-export * from "./social-community/instreet/index.js";
-export * from "./agent-network/evomap/index.js";
-export * from "./near-real/near-real-connector-smoke.js";
+export * from "./base/index.js";
+export * from "./social-community/moltbook/index.js";
+export * from "./social-community/instreet/index.js";
+export * from "./agent-network/evomap/index.js";
+export * from "./near-real/near-real-connector-smoke.js";

package/runtime/connectors/near-real/near-real-connector-smoke.d.ts

@@ -1,19 +1,19 @@
-import type { ObservabilityDatabase } from "../../observability/db/index.js";
-import type { StateDatabase } from "../../storage/db/index.js";
-export interface NearRealConnectorSmokeResult {
-    generatedAt: string;
-    platforms: {
-        social: "moltbook";
-        agentNetwork: "evomap";
-    };
-    feedReadEvidenceId?: string;
-    workDiscoverEvidenceId?: string;
-    taskClaimDryRunOk: boolean;
-    executionAttemptRowsForDecision: number;
-}
-export interface RunNearRealConnectorSmokeInput {
-    state: StateDatabase;
-    observabilityDb: ObservabilityDatabase;
-    workspaceRoot: string;
-}
-export declare function runNearRealConnectorSmoke(input: RunNearRealConnectorSmokeInput): Promise<NearRealConnectorSmokeResult>;
+import type { ObservabilityDatabase } from "../../observability/db/index.js";
+import type { StateDatabase } from "../../storage/db/index.js";
+export interface NearRealConnectorSmokeResult {
+    generatedAt: string;
+    platforms: {
+        social: "moltbook";
+        agentNetwork: "evomap";
+    };
+    feedReadEvidenceId?: string;
+    workDiscoverEvidenceId?: string;
+    taskClaimDryRunOk: boolean;
+    executionAttemptRowsForDecision: number;
+}
+export interface RunNearRealConnectorSmokeInput {
+    state: StateDatabase;
+    observabilityDb: ObservabilityDatabase;
+    workspaceRoot: string;
+}
+export declare function runNearRealConnectorSmoke(input: RunNearRealConnectorSmokeInput): Promise<NearRealConnectorSmokeResult>;