@zackbart/connecta 0.28.1 → 0.30.0

package/dist/json-schema.d.ts

@@ -1,2 +1,2 @@
 export { Validator } from "@cfworker/json-schema";
-export type { OutputUnit, Schema, SchemaDraft, ValidationResult, } from "@cfworker/json-schema";
+export type { OutputUnit, Schema, SchemaDraft, ValidationResult } from "@cfworker/json-schema";

package/dist/mcp-client-context.js

@@ -0,0 +1,35 @@
+import { CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY } from "@modelcontextprotocol/server";
+const RESERVED_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+/** A null-prototype copy, so a declared key can never shadow an inherited one. */
+function ownCapabilities(capabilities) {
+    const copy = Object.create(null);
+    for (const [key, value] of Object.entries(capabilities)) {
+        if (!RESERVED_KEYS.has(key))
+            copy[key] = value;
+    }
+    return copy;
+}
+/** Lift only the SDK-validated envelope, without retaining unrelated metadata. */
+export function bindMcpClient(context, client, activity) {
+    const envelope = context.mcpReq.envelope;
+    const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY];
+    const info = envelope?.[CLIENT_INFO_META_KEY];
+    delete client.clientCapabilities;
+    delete client.clientInfo;
+    if (capabilities && typeof capabilities === "object" && !Array.isArray(capabilities)) {
+        client.clientCapabilities = ownCapabilities(capabilities);
+    }
+    if (info &&
+        typeof info === "object" &&
+        "name" in info &&
+        "version" in info &&
+        typeof info.name === "string" &&
+        typeof info.version === "string") {
+        client.clientInfo = { name: info.name, version: info.version };
+    }
+    if (activity) {
+        delete activity.clientInfo;
+        if (client.clientInfo)
+            activity.clientInfo = client.clientInfo;
+    }
+}

package/dist/mcp-result.js

@@ -5,13 +5,13 @@ import { boundedEchoText } from "./errors.js";
  * JSON-parsed when possible. Downstream `isError` results become exceptions.
  * Non-MCP connectors already return plain values.
  */
-export function unwrapMcpResult(kind, result) {
+export function downstreamValue(kind, result) {
     if (kind !== "mcp" || result == null || typeof result !== "object") {
-        return result;
+        return { data: result, format: typeof result === "string" ? "text" : "json" };
     }
     const r = result;
     if ("toolResult" in r)
-        return r.toolResult;
+        return { data: r.toolResult, format: "json" };
     const content = Array.isArray(r.content) ? r.content : [];
     if (r.isError) {
         const text = content
@@ -21,15 +21,19 @@ export function unwrapMcpResult(kind, result) {
         throw new Error(boundedEchoText(text || "Tool call failed"));
     }
     if (r.structuredContent !== undefined)
-        return r.structuredContent;
+        return { data: r.structuredContent, format: "json" };
     if (content.length > 0 && content.every((c) => c.type === "text")) {
         const text = content.map((c) => c.text ?? "").join("\n");
         try {
-            return JSON.parse(text);
+            return { data: JSON.parse(text), format: "json" };
         }
         catch {
-            return text;
+            return { data: text, format: "text" };
         }
     }
-    return result;
+    return { data: result, format: "json" };
+}
+/** Preserve the raw-value API for internal callers that already know its format. */
+export function unwrapMcpResult(kind, result) {
+    return downstreamValue(kind, result).data;
 }

package/dist/meta-output.js

@@ -0,0 +1,61 @@
+import { Validator } from "@cfworker/json-schema";
+import { CATALOG_SEARCH_RESULT_SCHEMA } from "./catalog-service.js";
+import { z } from "zod";
+import { advertisedSchema } from "./advertised-schema.js";
+const error = z
+    .object({
+    code: z.string(),
+    message: z.string(),
+    retryable: z.boolean(),
+})
+    .passthrough();
+const format = z.enum(["json", "text"]);
+const counts = z.object({
+    attempted: z.number().int().nonnegative(),
+    admitted: z.number().int().nonnegative(),
+    succeeded: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+});
+export const EXECUTE_OUTPUT = advertisedSchema(z
+    .object({
+    result: z.unknown().optional(),
+    error: error.optional(),
+    hostCalls: counts,
+    logs: z.string().optional(),
+    emitted: z.number().int().nonnegative().optional(),
+    emittedDiscarded: z.number().int().nonnegative().optional(),
+    diagnostics: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough());
+export const SKILLS_OUTPUT = advertisedSchema(z
+    .object({
+    name: z.string().optional(),
+    text: z.string().optional(),
+    format: format.optional(),
+    skills: z.array(z.object({ name: z.string(), uri: z.string(), description: z.string() })).optional(),
+    error: error.optional(),
+})
+    .passthrough());
+// Catalog publication, SDK advertisement and validation share one schema.
+const searchValidator = new Validator(CATALOG_SEARCH_RESULT_SCHEMA, "2020-12", false);
+export const SEARCH_OUTPUT = {
+    "~standard": {
+        version: 1,
+        vendor: "connecta",
+        validate: (value) => searchValidator.validate(value).valid
+            ? { value: value }
+            : { issues: [{ message: "Expected a CatalogSearchResult." }] },
+        jsonSchema: {
+            input: () => CATALOG_SEARCH_RESULT_SCHEMA,
+            output: () => CATALOG_SEARCH_RESULT_SCHEMA,
+        },
+    },
+};
+export const AUTHORIZE_OUTPUT = advertisedSchema(z
+    .object({
+    connector: z.string().optional(),
+    recovery: z.string().optional(),
+    message: z.string().optional(),
+    error: error.optional(),
+})
+    .passthrough());

package/dist/meta-tool-names.d.ts

@@ -0,0 +1,2 @@
+/** The complete upward meta-tool set, shared with the CLI. */
+export declare const META_TOOL_NAMES: readonly string[];

package/dist/meta-tool-names.js

@@ -0,0 +1,3 @@
+import { META_TOOL_NAMES as names } from "../bin/meta-tool-names.mjs";
+/** The complete upward meta-tool set, shared with the CLI. */
+export const META_TOOL_NAMES = names;