@x12i/memorix-service 3.1.0 → 3.2.1

package/dist/execution-target.js

@@ -0,0 +1,853 @@
+import { AI_SERVICE_ORIGIN_SPECS, defaultEndpointEnvForType, resolveAiServiceOriginUrl, resolveConfiguredAiServiceOrigins, } from "./ai-services/config.js";
+import { createAiServicesClient } from "./ai-services/client.js";
+import { compileAuthoringPipeline, resolveKnowxWorkerBaseUrl, } from "./pipeline-compile.js";
+import { listUnifiedConnectors } from "./connector-catalog.js";
+import { loadGenericConnectorsConfig } from "./generic-connectors.js";
+export { classifyConnectorRole, normalizeCapabilityKeys, } from "./connector-role.js";
+const SYNTHETIC_PREFIX = "jm:";
+// Remove old local role helpers — re-exported from connector-role.ts above.
+export function isSyntheticPipelineId(pipelineId) {
+    return pipelineId.startsWith(SYNTHETIC_PREFIX);
+}
+export function syntheticPipelineId(target) {
+    switch (target.kind) {
+        case "pipeline":
+            return target.pipelineId;
+        case "connector":
+            return `${SYNTHETIC_PREFIX}connector:${encodeURIComponent(target.connectorId)}:${encodeURIComponent(target.sourceId)}`;
+        case "destination":
+            return `${SYNTHETIC_PREFIX}destination:${encodeURIComponent(target.connectorId)}:${encodeURIComponent(target.destinationId)}`;
+        case "service":
+            return `${SYNTHETIC_PREFIX}service:${encodeURIComponent(target.serviceId)}`;
+        case "ai-service":
+            return `${SYNTHETIC_PREFIX}ai:${encodeURIComponent(target.aiServiceType)}:${encodeURIComponent(target.itemId)}`;
+        case "runx":
+            return `${SYNTHETIC_PREFIX}runx:${encodeURIComponent(target.capabilityId)}`;
+    }
+}
+export function parseSyntheticPipelineId(pipelineId) {
+    if (!isSyntheticPipelineId(pipelineId))
+        return null;
+    const rest = pipelineId.slice(SYNTHETIC_PREFIX.length);
+    const [kind, ...parts] = rest.split(":");
+    if (kind === "connector" && parts.length >= 2) {
+        const connectorId = decodeURIComponent(parts[0] ?? "");
+        const sourceId = decodeURIComponent(parts.slice(1).join(":"));
+        if (!connectorId || !sourceId)
+            return null;
+        return { kind: "connector", connectorId, sourceId };
+    }
+    if (kind === "destination" && parts.length >= 2) {
+        const connectorId = decodeURIComponent(parts[0] ?? "");
+        const destinationId = decodeURIComponent(parts.slice(1).join(":"));
+        if (!connectorId || !destinationId)
+            return null;
+        return { kind: "destination", connectorId, destinationId };
+    }
+    if (kind === "service" && parts.length >= 1) {
+        const serviceId = decodeURIComponent(parts.join(":"));
+        if (!serviceId)
+            return null;
+        return { kind: "service", serviceId };
+    }
+    if (kind === "ai" && parts.length >= 2) {
+        const aiServiceType = decodeURIComponent(parts[0] ?? "");
+        const itemId = decodeURIComponent(parts.slice(1).join(":"));
+        if (!aiServiceType || !itemId)
+            return null;
+        return { kind: "ai-service", aiServiceType, itemId };
+    }
+    if (kind === "runx" && parts.length >= 1) {
+        const capabilityId = decodeURIComponent(parts.join(":"));
+        if (!capabilityId)
+            return null;
+        return { kind: "runx", capabilityId };
+    }
+    return null;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+/** Parse body.executionTarget or legacy body.pipelineId. */
+export function parseExecutionTarget(body) {
+    const rec = asRecord(body) ?? {};
+    const target = asRecord(rec.executionTarget) ?? asRecord(rec.target);
+    if (target) {
+        const kind = String(target.kind ?? "").trim();
+        if (kind === "pipeline") {
+            const pipelineId = String(target.pipelineId ?? "").trim();
+            if (!pipelineId)
+                throw new Error("executionTarget.pipelineId required");
+            return { kind: "pipeline", pipelineId };
+        }
+        if (kind === "connector") {
+            const connectorId = String(target.connectorId ?? "").trim();
+            const sourceId = String(target.sourceId ?? "").trim();
+            if (!connectorId)
+                throw new Error("executionTarget.connectorId required");
+            if (!sourceId) {
+                throw new Error("executionTarget.sourceId required (connector needs a configured source)");
+            }
+            return { kind: "connector", connectorId, sourceId };
+        }
+        if (kind === "destination") {
+            const connectorId = String(target.connectorId ?? "").trim();
+            const destinationId = String(target.destinationId ?? "").trim();
+            if (!connectorId)
+                throw new Error("executionTarget.connectorId required");
+            if (!destinationId) {
+                throw new Error("executionTarget.destinationId required (destination needs a configured destination)");
+            }
+            return { kind: "destination", connectorId, destinationId };
+        }
+        if (kind === "service") {
+            const serviceId = String(target.serviceId ?? "").trim();
+            if (!serviceId)
+                throw new Error("executionTarget.serviceId required");
+            return { kind: "service", serviceId };
+        }
+        if (kind === "ai-service" || kind === "ai") {
+            const aiServiceType = String(target.aiServiceType ?? "").trim();
+            const itemId = String(target.itemId ?? "").trim();
+            if (!aiServiceType)
+                throw new Error("executionTarget.aiServiceType required");
+            if (!itemId)
+                throw new Error("executionTarget.itemId required");
+            return { kind: "ai-service", aiServiceType, itemId };
+        }
+        if (kind === "runx") {
+            const capabilityId = String(target.capabilityId ?? "").trim();
+            if (!capabilityId)
+                throw new Error("executionTarget.capabilityId required");
+            return { kind: "runx", capabilityId };
+        }
+        throw new Error(`unsupported executionTarget.kind "${kind}"`);
+    }
+    const pipelineId = String(rec.pipelineId ?? "").trim();
+    if (pipelineId)
+        return { kind: "pipeline", pipelineId };
+    throw new Error("executionTarget or pipelineId required");
+}
+export function buildSyntheticAuthoringDefinition(target, opts) {
+    const pipelineId = syntheticPipelineId(target);
+    if (target.kind === "pipeline") {
+        throw new Error("buildSyntheticAuthoringDefinition requires a non-pipeline target");
+    }
+    if (target.kind === "connector") {
+        return {
+            id: pipelineId,
+            pipelineId,
+            name: opts?.sourceName
+                ? `Pull ${opts.sourceName}`
+                : `Pull ${target.sourceId}`,
+            version: "1",
+            trigger: "on-demand",
+            steps: [
+                {
+                    id: "pull",
+                    kind: "memory-pull",
+                    sourceId: target.sourceId,
+                    portConfig: {
+                        sourceId: target.sourceId,
+                        connectorId: target.connectorId,
+                        mode: "knowledge",
+                        trigger: "on-demand",
+                    },
+                },
+            ],
+        };
+    }
+    if (target.kind === "destination") {
+        return {
+            id: pipelineId,
+            pipelineId,
+            name: opts?.sourceName
+                ? `Deliver ${opts.sourceName}`
+                : `Deliver ${target.destinationId}`,
+            version: "1",
+            trigger: "on-demand",
+            steps: [
+                {
+                    id: "deliver",
+                    kind: "analyze",
+                    serviceId: `dest:${target.connectorId}:${target.destinationId}`,
+                    portConfig: {
+                        invokeProtocol: "memorix-destination/1",
+                        connectorId: target.connectorId,
+                        destinationId: target.destinationId,
+                    },
+                },
+            ],
+        };
+    }
+    if (target.kind === "service") {
+        const svc = (opts?.serviceDefs ?? []).find((s) => String(s.serviceId ?? s.id ?? "").trim() === target.serviceId);
+        const caps = Array.isArray(svc?.capabilities)
+            ? (svc.capabilities)
+            : [];
+        const kind = caps.includes("analyze") || caps.includes("enrich")
+            ? caps.includes("enrich")
+                ? "enrich"
+                : "analyze"
+            : "analyze";
+        return {
+            id: pipelineId,
+            pipelineId,
+            name: opts?.serviceName ?? target.serviceId,
+            version: "1",
+            trigger: "on-demand",
+            steps: [
+                {
+                    id: "invoke",
+                    kind,
+                    serviceId: target.serviceId,
+                },
+            ],
+        };
+    }
+    if (target.kind === "runx") {
+        return {
+            id: pipelineId,
+            pipelineId,
+            name: `Runx ${target.capabilityId}`,
+            version: "1",
+            trigger: "on-demand",
+            steps: [
+                {
+                    id: "runx",
+                    kind: "runx",
+                    capabilityId: target.capabilityId,
+                    portConfig: {
+                        capabilityId: target.capabilityId,
+                        invokeProtocol: "runx/1",
+                    },
+                },
+            ],
+        };
+    }
+    // ai-service
+    return {
+        id: pipelineId,
+        pipelineId,
+        name: opts?.itemTitle ?? `${target.aiServiceType}/${target.itemId}`,
+        version: "1",
+        trigger: "on-demand",
+        steps: [
+            {
+                id: "invoke",
+                kind: "analyze",
+                serviceId: `ai:${target.aiServiceType}:${target.itemId}`,
+                aiService: {
+                    aiServiceType: target.aiServiceType,
+                    itemId: target.itemId,
+                    endpointEnv: defaultEndpointEnvForType(target.aiServiceType),
+                },
+                portConfig: {
+                    aiServiceType: target.aiServiceType,
+                    itemId: target.itemId,
+                    invokeProtocol: "ai-services/1",
+                },
+            },
+        ],
+    };
+}
+function serviceDefsFromEffective(platform, agentIds) {
+    const effective = platform.metadata.resolveEffective(agentIds);
+    return (effective.effective ?? [])
+        .filter((e) => e.kind === "services")
+        .map((e) => e.definition);
+}
+function compileWithServices(platform, agentIds, definition) {
+    const serviceDefs = serviceDefsFromEffective(platform, agentIds);
+    const knownServiceIds = new Set(serviceDefs
+        .map((s) => String(s.serviceId ?? s.id ?? "").trim())
+        .filter(Boolean));
+    // Allow synthetic AI service ids through validation.
+    for (const step of (definition
+        .steps ?? [])) {
+        if (step.serviceId)
+            knownServiceIds.add(step.serviceId);
+    }
+    return compileAuthoringPipeline(definition, {
+        knownServiceIds,
+        workerBaseUrl: resolveKnowxWorkerBaseUrl(),
+        serviceDefs,
+    });
+}
+function findSource(platform, agentIds, orgId, sourceId) {
+    const effective = platform.metadata.resolveEffective(agentIds);
+    const pack = (effective.effective ?? []).find((e) => e.kind === "sources" && e.id === sourceId);
+    if (pack) {
+        const d = pack.definition;
+        return {
+            definition: d,
+            connectorRef: typeof d.connectorRef === "string"
+                ? d.connectorRef
+                : typeof d.kind === "string"
+                    ? d.kind
+                    : undefined,
+        };
+    }
+    return null;
+}
+async function findSourceIncludingOrg(platform, agentIds, orgId, sourceId) {
+    const pack = findSource(platform, agentIds, orgId, sourceId);
+    if (pack)
+        return pack;
+    if (!orgId)
+        return null;
+    const orgRows = await platform.orgRuntimeSourcesFor(orgId).list({ agentIds });
+    const row = orgRows.find((r) => r.sourceId === sourceId);
+    if (!row)
+        return null;
+    const d = row.definition;
+    return {
+        definition: d,
+        connectorRef: typeof d.connectorRef === "string"
+            ? d.connectorRef
+            : typeof d.kind === "string"
+                ? d.kind
+                : row.origin,
+    };
+}
+export async function resolveExecutionTarget(platform, opts) {
+    const { agentIds, orgId, target } = opts;
+    if (target.kind === "pipeline") {
+        const raw = platform.metadata.getDefinition(agentIds, "pipelines", target.pipelineId)?.definition;
+        if (!raw) {
+            throw new Error(`pipeline ${target.pipelineId} not found`);
+        }
+        const compiled = compileWithServices(platform, agentIds, raw);
+        const name = typeof raw.name === "string"
+            ? String(raw.name)
+            : target.pipelineId;
+        return {
+            target,
+            pipelineId: compiled.pipelineId || target.pipelineId,
+            compiled,
+            label: name,
+        };
+    }
+    if (target.kind === "connector") {
+        const source = await findSourceIncludingOrg(platform, agentIds, orgId, target.sourceId);
+        if (!source) {
+            throw new Error(`source ${target.sourceId} not found`);
+        }
+        const ref = source.connectorRef ?? "";
+        if (ref && ref !== target.connectorId) {
+            throw new Error(`source ${target.sourceId} is bound to connector ${ref}, not ${target.connectorId}`);
+        }
+        const sourceName = typeof source.definition.name === "string"
+            ? source.definition.name
+            : target.sourceId;
+        const authoring = buildSyntheticAuthoringDefinition(target, {
+            sourceName,
+            serviceDefs: serviceDefsFromEffective(platform, agentIds),
+        });
+        const compiled = compileWithServices(platform, agentIds, authoring);
+        // Ensure portConfig keeps sourceId after compile.
+        const step = compiled.steps[0];
+        if (step) {
+            step.portConfig = {
+                ...(step.portConfig ?? {}),
+                sourceId: target.sourceId,
+                connectorId: target.connectorId,
+                mode: "knowledge",
+                trigger: "on-demand",
+            };
+        }
+        return {
+            target,
+            pipelineId: syntheticPipelineId(target),
+            compiled: { ...compiled, pipelineId: syntheticPipelineId(target) },
+            label: sourceName,
+        };
+    }
+    if (target.kind === "destination") {
+        if (!orgId) {
+            throw new Error("orgId required for destination execution target");
+        }
+        if (!platform.destinationStore) {
+            throw new Error("destination store not available on platform");
+        }
+        const doc = await platform.destinationStore.get(orgId, target.destinationId);
+        if (!doc) {
+            throw new Error(`destination ${target.destinationId} not found`);
+        }
+        const ref = doc.definition.connectorRef ?? "";
+        if (ref && ref !== target.connectorId) {
+            throw new Error(`destination ${target.destinationId} is bound to connector ${ref}, not ${target.connectorId}`);
+        }
+        const destName = doc.definition.name || target.destinationId;
+        const authoring = buildSyntheticAuthoringDefinition(target, {
+            sourceName: destName,
+            serviceDefs: serviceDefsFromEffective(platform, agentIds),
+        });
+        const compiled = compileWithServices(platform, agentIds, authoring);
+        const step = compiled.steps[0];
+        if (step) {
+            step.portConfig = {
+                ...(step.portConfig ?? {}),
+                invokeProtocol: "memorix-destination/1",
+                connectorId: target.connectorId,
+                destinationId: target.destinationId,
+            };
+            // Ensure synthetic service id survives validation.
+            if (!step.serviceId) {
+                step.serviceId =
+                    `dest:${target.connectorId}:${target.destinationId}`;
+            }
+        }
+        return {
+            target,
+            pipelineId: syntheticPipelineId(target),
+            compiled: { ...compiled, pipelineId: syntheticPipelineId(target) },
+            label: destName,
+        };
+    }
+    if (target.kind === "service") {
+        const serviceDefs = serviceDefsFromEffective(platform, agentIds);
+        const svc = serviceDefs.find((s) => String(s.serviceId ?? s.id ?? "").trim() === target.serviceId);
+        if (!svc) {
+            throw new Error(`service ${target.serviceId} not found`);
+        }
+        const serviceName = typeof svc.name === "string"
+            ? String(svc.name)
+            : target.serviceId;
+        const authoring = buildSyntheticAuthoringDefinition(target, {
+            serviceDefs,
+            serviceName,
+        });
+        const compiled = compileWithServices(platform, agentIds, authoring);
+        const endpoint = compiled.steps[0]?.portConfig
+            ?.endpoint;
+        if (!endpoint && !compiled.steps[0]?.portConfig?.invokeProtocol) {
+            // Worker endpoint always resolves to a default base; AI may fall through.
+            // Accept as available — runtime will fail clearly if worker is down.
+        }
+        return {
+            target,
+            pipelineId: syntheticPipelineId(target),
+            compiled: { ...compiled, pipelineId: syntheticPipelineId(target) },
+            label: serviceName,
+        };
+    }
+    if (target.kind === "runx") {
+        const authoring = buildSyntheticAuthoringDefinition(target);
+        const compiled = compileWithServices(platform, agentIds, authoring);
+        return {
+            target,
+            pipelineId: syntheticPipelineId(target),
+            compiled: { ...compiled, pipelineId: syntheticPipelineId(target) },
+            label: `Runx ${target.capabilityId}`,
+        };
+    }
+    // ai-service
+    const origin = resolveAiServiceOriginUrl(target.aiServiceType);
+    if (!origin) {
+        throw new Error(`No origin configured for aiServiceType "${target.aiServiceType}"`);
+    }
+    const authoring = buildSyntheticAuthoringDefinition(target, {
+        serviceDefs: serviceDefsFromEffective(platform, agentIds),
+        itemTitle: `${target.aiServiceType}/${target.itemId}`,
+    });
+    // Inject a synthetic service def so compile stamps AI portConfig.
+    const aiServiceDef = {
+        id: `ai:${target.aiServiceType}:${target.itemId}`,
+        serviceId: `ai:${target.aiServiceType}:${target.itemId}`,
+        aiService: {
+            aiServiceType: target.aiServiceType,
+            itemId: target.itemId,
+            endpointEnv: defaultEndpointEnvForType(target.aiServiceType),
+        },
+        invocation: {
+            operation: target.itemId,
+            aiServiceType: target.aiServiceType,
+            itemId: target.itemId,
+            endpointEnv: defaultEndpointEnvForType(target.aiServiceType),
+        },
+    };
+    const serviceDefs = [
+        ...serviceDefsFromEffective(platform, agentIds),
+        aiServiceDef,
+    ];
+    const knownServiceIds = new Set(serviceDefs
+        .map((s) => String(s.serviceId ?? s.id ?? "").trim())
+        .filter(Boolean));
+    const compiled = compileAuthoringPipeline(authoring, {
+        knownServiceIds,
+        workerBaseUrl: resolveKnowxWorkerBaseUrl(),
+        serviceDefs,
+    });
+    const pc = compiled.steps[0]?.portConfig;
+    if (pc?.invokeProtocol !== "ai-services/1" || !pc.endpoint) {
+        // Force stamp if compile fell through to worker.
+        if (compiled.steps[0]) {
+            compiled.steps[0].portConfig = {
+                ...(compiled.steps[0].portConfig ?? {}),
+                serviceId: aiServiceDef.serviceId,
+                operation: target.itemId,
+                endpoint: origin,
+                aiServiceType: target.aiServiceType,
+                itemId: target.itemId,
+                invokeProtocol: "ai-services/1",
+            };
+        }
+    }
+    return {
+        target,
+        pipelineId: syntheticPipelineId(target),
+        compiled: { ...compiled, pipelineId: syntheticPipelineId(target) },
+        label: `${target.aiServiceType}/${target.itemId}`,
+    };
+}
+/** Resolve by pipelineId — installed or synthetic. */
+export async function resolvePipelineIdAsTarget(platform, opts) {
+    const fromSynthetic = parseSyntheticPipelineId(opts.pipelineId);
+    if (fromSynthetic) {
+        return resolveExecutionTarget(platform, {
+            agentIds: opts.agentIds,
+            orgId: opts.orgId,
+            target: fromSynthetic,
+        });
+    }
+    return resolveExecutionTarget(platform, {
+        agentIds: opts.agentIds,
+        orgId: opts.orgId,
+        target: { kind: "pipeline", pipelineId: opts.pipelineId },
+    });
+}
+export async function listExecutionTargets(platform, opts) {
+    const { agentIds, orgId } = opts;
+    const effective = platform.metadata.resolveEffective(agentIds);
+    const entries = effective.effective ?? [];
+    const pipelines = entries
+        .filter((e) => e.kind === "pipelines")
+        .map((e) => {
+        const d = e.definition;
+        const pipelineId = String(d.id ?? d.pipelineId ?? e.id).trim();
+        const steps = Array.isArray(d.steps) ? d.steps : [];
+        return {
+            kind: "pipeline",
+            id: pipelineId,
+            name: typeof d.name === "string" ? d.name : pipelineId,
+            description: typeof d.description === "string" ? d.description : undefined,
+            available: true,
+            capabilities: [`${steps.length} steps`],
+            target: { kind: "pipeline", pipelineId },
+            meta: {
+                trigger: typeof d.trigger === "string" ? d.trigger : undefined,
+                stepCount: steps.length,
+            },
+        };
+    });
+    // Sources (pack + org)
+    const packSources = entries
+        .filter((e) => e.kind === "sources")
+        .map((e) => ({
+        sourceId: e.id,
+        definition: e.definition,
+        connectorRef: typeof e.definition.connectorRef === "string"
+            ? e.definition.connectorRef
+            : typeof e.definition.kind === "string"
+                ? String(e.definition.kind)
+                : undefined,
+    }));
+    const orgSources = orgId != null
+        ? (await platform.orgRuntimeSourcesFor(orgId).list({ agentIds })).map((r) => ({
+            sourceId: r.sourceId,
+            definition: r.definition,
+            connectorRef: typeof r.definition.connectorRef === "string"
+                ? r.definition.connectorRef
+                : typeof r.definition.kind === "string"
+                    ? String(r.definition.kind)
+                    : r.origin,
+        }))
+        : [];
+    const sourceById = new Map();
+    for (const s of [...packSources, ...orgSources]) {
+        if (!sourceById.has(s.sourceId))
+            sourceById.set(s.sourceId, s);
+    }
+    const unified = await listUnifiedConnectors({
+        connectorRegistry: platform.connectorRegistry,
+        genericConnectors: platform.genericConnectors ?? loadGenericConnectorsConfig(),
+    });
+    const destinations = orgId != null && platform.destinationStore
+        ? await platform.destinationStore.list(orgId)
+        : [];
+    const sourceConnectors = [];
+    const targetConnectors = [];
+    for (const c of unified) {
+        if (!c.connectorRole)
+            continue;
+        const sources = [...sourceById.values()].filter((s) => s.connectorRef === c.id);
+        const sourceChildren = sources.map((s) => {
+            const name = typeof s.definition.name === "string" ? s.definition.name : s.sourceId;
+            return {
+                kind: "connector",
+                id: `${c.id}:${s.sourceId}`,
+                name,
+                description: `Source ${s.sourceId} via ${c.displayName}`,
+                available: c.enabled && !c.unavailableReason,
+                unavailableReason: c.enabled
+                    ? c.unavailableReason
+                    : "Connector disabled",
+                target: {
+                    kind: "connector",
+                    connectorId: c.id,
+                    sourceId: s.sourceId,
+                },
+                meta: {
+                    connectorId: c.id,
+                    sourceId: s.sourceId,
+                    origin: c.origin,
+                },
+            };
+        });
+        const destChildren = destinations
+            .filter((d) => d.definition.connectorRef === c.id)
+            .map((d) => {
+            const destId = d.definition.id;
+            return {
+                kind: "destination",
+                id: `${c.id}:dest:${destId}`,
+                name: d.definition.name || destId,
+                description: `Destination ${destId} via ${c.displayName}`,
+                available: c.enabled && !c.unavailableReason,
+                unavailableReason: c.unavailableReason,
+                target: {
+                    kind: "destination",
+                    connectorId: c.id,
+                    destinationId: destId,
+                },
+                meta: {
+                    connectorId: c.id,
+                    destinationId: destId,
+                    origin: c.origin,
+                    hostBaseUrl: d.definition.hostBaseUrl ?? c.hostBaseUrl,
+                },
+            };
+        });
+        const baseMeta = {
+            connectorId: c.id,
+            connectorRole: c.connectorRole,
+            origin: c.origin,
+            ...(c.hostBaseUrl ? { hostBaseUrl: c.hostBaseUrl } : {}),
+            ...(c.remoteHosting ? { remoteHosting: true } : {}),
+        };
+        if (c.isSource) {
+            const hostBlock = c.unavailableReason;
+            sourceConnectors.push({
+                kind: "connector",
+                id: c.id,
+                name: c.displayName,
+                description: hostBlock
+                    ? hostBlock
+                    : `Source connector · ${sourceChildren.length} configured source(s)${c.origin === "generic-connectors" ? " · Generic" : ""}`,
+                available: sourceChildren.length > 0 && c.enabled && !hostBlock,
+                unavailableReason: !c.enabled
+                    ? "Connector disabled"
+                    : hostBlock
+                        ? hostBlock
+                        : sourceChildren.length === 0
+                            ? "No configured source — bind a source in Studio first"
+                            : undefined,
+                capabilities: c.capabilityKeys,
+                target: {
+                    kind: "connector",
+                    connectorId: c.id,
+                    sourceId: sourceChildren[0]?.meta?.sourceId
+                        ? String(sourceChildren[0].meta.sourceId)
+                        : "",
+                },
+                children: sourceChildren,
+                meta: baseMeta,
+            });
+        }
+        if (c.isTarget) {
+            const hostBlock = c.unavailableReason;
+            targetConnectors.push({
+                kind: "destination",
+                id: c.id,
+                name: c.displayName,
+                description: hostBlock
+                    ? hostBlock
+                    : `Target connector · ${destChildren.length} configured destination(s)${c.origin === "generic-connectors" ? " · Generic" : ""}`,
+                available: destChildren.length > 0 && c.enabled && !hostBlock,
+                unavailableReason: !c.enabled
+                    ? "Connector disabled"
+                    : hostBlock
+                        ? hostBlock
+                        : destChildren.length === 0
+                            ? "No configured destination — create one via Memory destinations API first"
+                            : undefined,
+                capabilities: c.capabilityKeys,
+                target: {
+                    kind: "destination",
+                    connectorId: c.id,
+                    destinationId: destChildren[0]?.meta?.destinationId
+                        ? String(destChildren[0].meta.destinationId)
+                        : "",
+                },
+                children: destChildren,
+                meta: baseMeta,
+            });
+        }
+    }
+    /** Compat alias — source connectors only. */
+    const connectors = sourceConnectors;
+    const services = entries
+        .filter((e) => e.kind === "services")
+        .map((e) => {
+        const d = e.definition;
+        const serviceId = String(d.id ?? d.serviceId ?? e.id).trim();
+        const caps = Array.isArray(d.capabilities)
+            ? d.capabilities
+            : [];
+        const ai = asRecord(d.aiService);
+        return {
+            kind: "service",
+            id: serviceId,
+            name: typeof d.name === "string" ? d.name : serviceId,
+            description: typeof d.description === "string" ? d.description : undefined,
+            available: true,
+            capabilities: caps,
+            target: { kind: "service", serviceId },
+            meta: {
+                role: typeof d.role === "string" ? d.role : undefined,
+                aiServiceType: typeof ai?.aiServiceType === "string" ? ai.aiServiceType : undefined,
+                itemId: typeof ai?.itemId === "string" ? ai.itemId : undefined,
+            },
+        };
+    });
+    const client = createAiServicesClient({ timeoutMs: 4_000 });
+    const origins = resolveConfiguredAiServiceOrigins();
+    const aiServices = await Promise.all(AI_SERVICE_ORIGIN_SPECS.map(async (spec) => {
+        const origin = origins.find((o) => o.aiServiceType === spec.aiServiceType);
+        const url = origin?.url ?? null;
+        if (!url) {
+            return {
+                kind: "ai-service",
+                id: spec.aiServiceType,
+                name: spec.aiServiceType,
+                description: `Set ${spec.env} to enable`,
+                available: false,
+                unavailableReason: `No origin configured (${spec.env})`,
+                target: {
+                    kind: "ai-service",
+                    aiServiceType: spec.aiServiceType,
+                    itemId: "",
+                },
+                children: [],
+                meta: { aiServiceType: spec.aiServiceType, env: spec.env },
+            };
+        }
+        try {
+            const health = await client.getHealth(url);
+            if (!health.ok) {
+                return {
+                    kind: "ai-service",
+                    id: spec.aiServiceType,
+                    name: spec.aiServiceType,
+                    description: url,
+                    available: false,
+                    unavailableReason: `Companion unreachable (HTTP ${health.status})`,
+                    target: {
+                        kind: "ai-service",
+                        aiServiceType: spec.aiServiceType,
+                        itemId: "",
+                    },
+                    children: [],
+                    meta: { aiServiceType: spec.aiServiceType, url },
+                };
+            }
+            const items = await client.listItems(url, { limit: 200 });
+            const children = items.map((item) => ({
+                kind: "ai-service",
+                id: `${spec.aiServiceType}:${item.id}`,
+                name: item.title || item.id,
+                description: item.summary,
+                available: true,
+                capabilities: item.tags,
+                target: {
+                    kind: "ai-service",
+                    aiServiceType: spec.aiServiceType,
+                    itemId: item.id,
+                },
+                meta: {
+                    aiServiceType: spec.aiServiceType,
+                    itemId: item.id,
+                    version: item.version,
+                },
+            }));
+            return {
+                kind: "ai-service",
+                id: spec.aiServiceType,
+                name: spec.aiServiceType,
+                description: `${children.length} item(s) · ${url}`,
+                available: children.length > 0,
+                unavailableReason: children.length === 0 ? "No catalog items" : undefined,
+                target: {
+                    kind: "ai-service",
+                    aiServiceType: spec.aiServiceType,
+                    itemId: children[0]?.meta?.itemId
+                        ? String(children[0].meta.itemId)
+                        : "",
+                },
+                children,
+                meta: { aiServiceType: spec.aiServiceType, url },
+            };
+        }
+        catch (err) {
+            return {
+                kind: "ai-service",
+                id: spec.aiServiceType,
+                name: spec.aiServiceType,
+                description: url,
+                available: false,
+                unavailableReason: err instanceof Error ? err.message : String(err),
+                target: {
+                    kind: "ai-service",
+                    aiServiceType: spec.aiServiceType,
+                    itemId: "",
+                },
+                children: [],
+                meta: { aiServiceType: spec.aiServiceType, url },
+            };
+        }
+    }));
+    const runxEnabled = process.env.RUNX_ENABLED === "1" ||
+        process.env.RUNX_ENABLED === "true" ||
+        Boolean(process.env.FIREBASE_PROJECT_ID?.trim() ||
+            process.env.GOOGLE_SERVICE_ACCOUNT_BASE64?.trim() ||
+            process.env.CATALOX_MONGO_URI?.trim());
+    const runx = [
+        {
+            kind: "runx",
+            id: "runx",
+            name: "Runx",
+            description: runxEnabled
+                ? "Run a Runx capability by id (set capabilityId on work target)"
+                : "Configure Catalox/Runx (RUNX_ENABLED or FIREBASE_*/CATALOX_*)",
+            available: runxEnabled,
+            unavailableReason: runxEnabled
+                ? undefined
+                : "Runx not configured",
+            target: { kind: "runx", capabilityId: "" },
+            meta: { note: "Pass capabilityId in executionTarget" },
+        },
+    ];
+    return {
+        pipelines,
+        connectors,
+        sourceConnectors,
+        targetConnectors,
+        services,
+        aiServices,
+        runx,
+    };
+}
+//# sourceMappingURL=execution-target.js.map