@haaaiawd/second-nature 0.1.1 → 0.1.2

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

@@ -0,0 +1,105 @@
+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",
+    "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,
+    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 === "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 };
+        }
+        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 };
+}

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

@@ -0,0 +1,6 @@
+export * from "./contract.js";
+export * from "./manifest.js";
+export * from "./failure-taxonomy.js";
+export * from "./route-planner.js";
+export * from "./channel-health.js";
+export * from "./policy-layer.js";

package/runtime/connectors/base/index.js

@@ -0,0 +1,6 @@
+export * from "./contract.js";
+export * from "./manifest.js";
+export * from "./failure-taxonomy.js";
+export * from "./route-planner.js";
+export * from "./channel-health.js";
+export * from "./policy-layer.js";

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

@@ -0,0 +1,11 @@
+import { type CapabilityIntent, type ChannelType, type ConnectorManifestLike } from "./contract.js";
+export type ConnectorManifest = ConnectorManifestLike;
+export declare class CapabilityContractRegistry {
+    private readonly byPlatform;
+    register(manifest: ConnectorManifest): void;
+    loadManifest(platformId: string): ConnectorManifest;
+    hasCapability(platformId: string, intent: CapabilityIntent): boolean;
+    listCapabilities(platformId: string): CapabilityIntent[];
+    listChannels(platformId: string): ChannelType[];
+}
+export declare function parseConnectorManifest(input: unknown): ConnectorManifest;

package/runtime/connectors/base/manifest.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { CAPABILITY_INTENTS, CHANNEL_TYPES } from "./contract.js";
+const connectorManifestSchema = z.object({
+    platformId: z.string().min(1),
+    supportedCapabilities: z.array(z.enum(CAPABILITY_INTENTS)).min(1),
+    channelPriority: z.array(z.enum(CHANNEL_TYPES)).min(1),
+    credentialTypes: z.array(z.string().min(1)).min(1),
+    degradedChannels: z.array(z.enum(CHANNEL_TYPES)).optional(),
+});
+export class CapabilityContractRegistry {
+    byPlatform = new Map();
+    register(manifest) {
+        const parsed = connectorManifestSchema.parse(manifest);
+        this.byPlatform.set(parsed.platformId, parsed);
+    }
+    loadManifest(platformId) {
+        const found = this.byPlatform.get(platformId);
+        if (!found) {
+            throw new Error(`connector_manifest_not_found:${platformId}`);
+        }
+        return found;
+    }
+    hasCapability(platformId, intent) {
+        const manifest = this.loadManifest(platformId);
+        return manifest.supportedCapabilities.includes(intent);
+    }
+    listCapabilities(platformId) {
+        return [...this.loadManifest(platformId).supportedCapabilities];
+    }
+    listChannels(platformId) {
+        return [...this.loadManifest(platformId).channelPriority];
+    }
+}
+export function parseConnectorManifest(input) {
+    return connectorManifestSchema.parse(input);
+}

package/runtime/connectors/base/policy-layer.d.ts

@@ -0,0 +1,27 @@
+import { type FailureClass } from "./failure-taxonomy.js";
+import type { CapabilityIntent, ConnectorRequest, ConnectorResult, ExecutionPlan, ExecutionRunner, RoutePlanner } from "./contract.js";
+import type { ExecutionTelemetry } from "../../observability/services/execution-telemetry.js";
+export interface RetryPolicy {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    jitter: boolean;
+}
+export interface CooldownPort {
+    isBlocked(platformId: string, intent: CapabilityIntent): Promise<{
+        blocked: boolean;
+        retryAfterMs?: number;
+    }>;
+    markFailure(platformId: string, intent: CapabilityIntent, failureClass: FailureClass, retryAfterMs?: number): Promise<void>;
+}
+export interface ConnectorPolicyContext {
+    routePlanner: RoutePlanner;
+    executionRunner: ExecutionRunner;
+    telemetry?: ExecutionTelemetry;
+    cooldownPort?: CooldownPort;
+    retryPolicy?: Partial<RetryPolicy>;
+    allowDegradedFallback?: (plan: ExecutionPlan, request: ConnectorRequest) => boolean;
+}
+export declare function createConnectorPolicyLayer(ctx: ConnectorPolicyContext): {
+    executeWithPolicy(intent: CapabilityIntent, request: ConnectorRequest): Promise<ConnectorResult<unknown>>;
+};

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

@@ -0,0 +1,213 @@
+import { classifyFailure } from "./failure-taxonomy.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,
+                    },
+                };
+            }
+            let lastFailure;
+            for (let attempt = 1; attempt <= retryPolicy.maxRetries; attempt += 1) {
+                const traceId = makeTraceId(request, plan);
+                const attemptId = `attempt-${traceId}-${attempt}`;
+                if (ctx.telemetry) {
+                    await ctx.telemetry.recordExecutionAttempt({
+                        id: attemptId,
+                        traceId,
+                        decisionId: identity.decisionId,
+                        intentId: identity.intentId,
+                        platformId: request.platformId,
+                        capability: request.intent,
+                        channel: plan.channel,
+                        status: "started",
+                        retryPolicy: JSON.stringify(retryPolicy),
+                        idempotencyKey: request.idempotencyKey,
+                        startedAt: new Date().toISOString(),
+                    });
+                }
+                const raw = await ctx.executionRunner.run(plan, request);
+                if (raw.success) {
+                    if (ctx.telemetry) {
+                        await ctx.telemetry.recordExecutionAttempt({
+                            id: `${attemptId}-done`,
+                            traceId,
+                            decisionId: identity.decisionId,
+                            intentId: identity.intentId,
+                            platformId: request.platformId,
+                            capability: request.intent,
+                            channel: plan.channel,
+                            status: "succeeded",
+                            retryPolicy: JSON.stringify(retryPolicy),
+                            idempotencyKey: request.idempotencyKey,
+                            startedAt: new Date().toISOString(),
+                            finishedAt: new Date().toISOString(),
+                        });
+                    }
+                    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.recordExecutionAttempt({
+                        id: `${attemptId}-failed`,
+                        traceId,
+                        decisionId: identity.decisionId,
+                        intentId: identity.intentId,
+                        platformId: request.platformId,
+                        capability: request.intent,
+                        channel: plan.channel,
+                        status: "failed",
+                        failureClass: classified.class,
+                        retryPolicy: JSON.stringify(retryPolicy),
+                        idempotencyKey: request.idempotencyKey,
+                        startedAt: new Date().toISOString(),
+                        finishedAt: new Date().toISOString(),
+                    });
+                }
+                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.d.ts

@@ -0,0 +1,10 @@
+import { type CapabilityIntent, type ConnectorRequest, type ExecutionPlan, type RouteContextPort } from "./contract.js";
+import type { CapabilityContractRegistry } from "./manifest.js";
+import { ChannelHealthStore } from "./channel-health.js";
+export declare class ConnectorRoutePlanner {
+    private readonly registry;
+    private readonly statePort;
+    private readonly channelHealth;
+    constructor(registry: CapabilityContractRegistry, statePort: RouteContextPort, channelHealth: ChannelHealthStore);
+    planRoute(intent: CapabilityIntent, request: ConnectorRequest): Promise<ExecutionPlan>;
+}

package/runtime/connectors/base/route-planner.js

@@ -0,0 +1,98 @@
+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,
+        };
+    }
+}

package/runtime/connectors/index.d.ts

@@ -0,0 +1,4 @@
+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";

package/runtime/connectors/index.js

@@ -0,0 +1,4 @@
+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";

package/runtime/connectors/social-community/instreet/adapter.d.ts

@@ -0,0 +1,32 @@
+import type { CredentialContext } from "../../../shared/types/credential.js";
+import type { ConnectorRequest, ExecutionPlan, RawAttempt } from "../../base/contract.js";
+export interface InStreetApiClient {
+    listNotifications(payload: Record<string, unknown>, apiKey: string): Promise<unknown>;
+    sendMessage(payload: Record<string, unknown>, apiKey: string): Promise<unknown>;
+    replyComment(payload: Record<string, unknown>, apiKey: string): Promise<unknown>;
+    heartbeat(apiKey: string): Promise<unknown>;
+}
+export interface InStreetSkillRunner {
+    resumeVerification(ctx: CredentialContext): Promise<{
+        apiKey?: string;
+        status: "active" | "failed";
+    }>;
+    run(intent: ExecutionPlan["intent"], payload: Record<string, unknown>, context: {
+        credential: CredentialContext;
+        apiKey?: string;
+    }): Promise<unknown>;
+}
+export interface InStreetCredentialPort {
+    loadCredentialState(platformId: string): Promise<CredentialContext>;
+    persistVerificationOutcome(platformId: string, outcome: {
+        status: "active" | "failed";
+        apiKey?: string;
+    }): Promise<void>;
+}
+export declare function createInStreetRunner(input: {
+    apiClient: InStreetApiClient;
+    credentialPort: InStreetCredentialPort;
+    skillRunner: InStreetSkillRunner;
+}): {
+    run(plan: ExecutionPlan, request: ConnectorRequest): Promise<RawAttempt>;
+};

package/runtime/connectors/social-community/instreet/adapter.js

@@ -0,0 +1,79 @@
+export function createInStreetRunner(input) {
+    const { apiClient, credentialPort, skillRunner } = input;
+    return {
+        async run(plan, request) {
+            const started = Date.now();
+            try {
+                const credential = await credentialPort.loadCredentialState(request.platformId);
+                const apiKey = await ensureActiveApiKey(request.platformId, credential, credentialPort, skillRunner, plan.channel);
+                const payload = await executeInStreet(plan, request.payload, apiClient, skillRunner, credential, apiKey);
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    degraded: plan.channel === "skill" || plan.channel === "browser",
+                    success: true,
+                    payload: {
+                        capability: request.intent,
+                        channel: plan.channel,
+                        data: payload,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    degraded: plan.channel === "skill" || plan.channel === "browser",
+                    success: false,
+                    error,
+                };
+            }
+        },
+    };
+}
+async function ensureActiveApiKey(platformId, credential, credentialPort, skillRunner, channel) {
+    if (credential.status === "pending_verification") {
+        if (channel !== "skill" && channel !== "browser") {
+            throw { code: "verification_required", detail: "instreet verification requires skill_or_browser channel" };
+        }
+        const outcome = await skillRunner.resumeVerification(credential);
+        await credentialPort.persistVerificationOutcome(platformId, {
+            status: outcome.status,
+            apiKey: outcome.apiKey,
+        });
+        if (outcome.status !== "active") {
+            throw { code: "verification_required", detail: "instreet verification still pending" };
+        }
+        if (!outcome.apiKey) {
+            throw { code: "auth_failure", detail: "instreet verification returned active_without_api_key" };
+        }
+        return outcome.apiKey;
+    }
+    if (credential.status !== "active" || !credential.encryptedValue) {
+        throw { code: "auth_failure", detail: `instreet credential not active: ${credential.status}` };
+    }
+    return credential.encryptedValue;
+}
+async function executeInStreet(plan, payload, apiClient, skillRunner, credential, apiKey) {
+    if (plan.channel !== "api_rest" && plan.channel !== "skill" && plan.channel !== "browser") {
+        throw { code: "protocol_mismatch", detail: `unsupported instreet channel: ${plan.channel}` };
+    }
+    if (plan.channel === "skill" || plan.channel === "browser") {
+        return skillRunner.run(plan.intent, payload, { credential, apiKey });
+    }
+    if (plan.intent === "notification.list") {
+        return apiClient.listNotifications(payload, apiKey);
+    }
+    if (plan.intent === "message.send") {
+        return apiClient.sendMessage(payload, apiKey);
+    }
+    if (plan.intent === "comment.reply") {
+        return apiClient.replyComment(payload, apiKey);
+    }
+    if (plan.intent === "agent.heartbeat") {
+        return apiClient.heartbeat(apiKey);
+    }
+    throw { code: "protocol_mismatch", detail: `unsupported instreet intent: ${plan.intent}` };
+}

package/runtime/connectors/social-community/instreet/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./manifest.js";
+export * from "./adapter.js";

package/runtime/connectors/social-community/instreet/index.js

@@ -0,0 +1,2 @@
+export * from "./manifest.js";
+export * from "./adapter.js";

package/runtime/connectors/social-community/instreet/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ConnectorManifest } from "../../base/manifest.js";
+export declare const instreetManifest: ConnectorManifest;

package/runtime/connectors/social-community/instreet/manifest.js

@@ -0,0 +1,7 @@
+export const instreetManifest = {
+    platformId: "instreet",
+    supportedCapabilities: ["notification.list", "message.send", "comment.reply", "agent.heartbeat"],
+    channelPriority: ["api_rest", "skill", "browser"],
+    credentialTypes: ["api_key", "verification_code"],
+    degradedChannels: ["skill", "browser"],
+};