@decocms/runtime 1.0.0-alpha.5 → 1.0.1

package/src/proxy.ts

@@ -1,208 +1 @@
-/* oxlint-disable no-explicit-any */
-import type { ToolExecutionContext as _ToolExecutionContext } from "@mastra/core";
-import { convertJsonSchemaToZod } from "zod-from-json-schema";
-import { MCPConnection } from "./connection.ts";
-import { createServerClient } from "./mcp-client.ts";
-import type { CreateStubAPIOptions } from "./mcp.ts";
-import { WELL_KNOWN_API_HOSTNAMES } from "./well-known.ts";
-
-const getWorkspace = (workspace?: string) => {
-  if (workspace && workspace.length > 0 && !workspace.includes("/")) {
-    return `/shared/${workspace}`;
-  }
-  return workspace ?? "";
-};
-
-const safeParse = (content: string) => {
-  try {
-    return JSON.parse(content as string);
-  } catch {
-    return content;
-  }
-};
-
-const toolsMap = new Map<
-  string,
-  Promise<
-    Array<{
-      name: string;
-      inputSchema: any;
-      outputSchema?: any;
-      description: string;
-    }>
-  >
->();
-
-/**
- * Determines if a given URL supports tool names in the path.
- * Our APIs (api.decocms.com, api.deco.chat, localhost) support /tool/${toolName} routing.
- * Third-party APIs typically don't support this pattern.
- */
-function supportsToolNameInPath(url: string): boolean {
-  try {
-    // Our main APIs that support /tool/${toolName} routing
-    return WELL_KNOWN_API_HOSTNAMES.includes(new URL(url).hostname);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * The base fetcher used to fetch the MCP from API.
- */
-export function createMCPClientProxy<T extends Record<string, unknown>>(
-  options?: CreateStubAPIOptions,
-): T {
-  const mcpPath = options?.mcpPath ?? "/mcp";
-
-  const connection: MCPConnection = options?.connection || {
-    type: "HTTP",
-    token: options?.token,
-    url: new URL(
-      `${getWorkspace(options?.workspace)}${mcpPath}`,
-      options?.decoCmsApiUrl ?? `https://api.decocms.com`,
-    ).href,
-  };
-
-  return new Proxy<T>({} as T, {
-    get(_, name) {
-      if (name === "toJSON") {
-        return null;
-      }
-      if (typeof name !== "string") {
-        throw new Error("Name must be a string");
-      }
-      async function callToolFn(args: unknown) {
-        const debugId = options?.debugId?.();
-        const extraHeaders = debugId
-          ? { "x-trace-debug-id": debugId }
-          : undefined;
-
-        // Create a connection with the tool name in the URL path for better logging
-        // Only modify connections that have a URL property (HTTP, SSE, Websocket)
-        // Use automatic detection based on URL, with optional override
-        let toolConnection = connection;
-        const shouldAddToolName =
-          options?.supportsToolName ??
-          ("url" in connection &&
-            typeof connection.url === "string" &&
-            supportsToolNameInPath(connection.url));
-
-        if (
-          shouldAddToolName &&
-          "url" in connection &&
-          typeof connection.url === "string"
-        ) {
-          toolConnection = {
-            ...connection,
-            url: connection.url.endsWith("/")
-              ? `${connection.url}tool/${String(name)}`
-              : `${connection.url}/tool/${String(name)}`,
-          };
-        }
-
-        const { client, callStreamableTool } = await createServerClient(
-          { connection: toolConnection },
-          undefined,
-          extraHeaders,
-        );
-
-        if (options?.streamable?.[String(name)]) {
-          return callStreamableTool(String(name), args);
-        }
-
-        const { structuredContent, isError, content } = await client.callTool(
-          {
-            name: String(name),
-            arguments: args as Record<string, unknown>,
-          },
-          undefined,
-          {
-            timeout: 3000000,
-          },
-        );
-
-        if (isError) {
-          // @ts-expect-error - content is not typed
-          const maybeErrorMessage = content?.[0]?.text;
-          const error =
-            typeof maybeErrorMessage === "string"
-              ? safeParse(maybeErrorMessage)
-              : null;
-
-          const throwableError =
-            error?.code && typeof options?.getErrorByStatusCode === "function"
-              ? options.getErrorByStatusCode(
-                  error.code,
-                  error.message,
-                  error.traceId,
-                )
-              : null;
-
-          if (throwableError) {
-            throw throwableError;
-          }
-
-          throw new Error(
-            `Tool ${String(name)} returned an error: ${JSON.stringify(
-              structuredContent ?? content,
-            )}`,
-          );
-        }
-        return structuredContent;
-      }
-
-      const listToolsFn = async () => {
-        const { client } = await createServerClient({ connection });
-        const { tools } = await client.listTools();
-
-        return tools as {
-          name: string;
-          inputSchema: any;
-          outputSchema?: any;
-          description: string;
-        }[];
-      };
-
-      async function listToolsOnce() {
-        const conn = connection;
-        const key = JSON.stringify(conn);
-
-        try {
-          if (!toolsMap.has(key)) {
-            toolsMap.set(key, listToolsFn());
-          }
-
-          return await toolsMap.get(key)!;
-        } catch (error) {
-          console.error("Failed to list tools", error);
-
-          toolsMap.delete(key);
-          return;
-        }
-      }
-      callToolFn.asTool = async () => {
-        const tools = (await listToolsOnce()) ?? [];
-        const tool = tools.find((t) => t.name === name);
-        if (!tool) {
-          throw new Error(`Tool ${name} not found`);
-        }
-
-        return {
-          ...tool,
-          id: tool.name,
-          inputSchema: tool.inputSchema
-            ? convertJsonSchemaToZod(tool.inputSchema)
-            : undefined,
-          outputSchema: tool.outputSchema
-            ? convertJsonSchemaToZod(tool.outputSchema)
-            : undefined,
-          execute: (input: any) => {
-            return callToolFn(input.context);
-          },
-        };
-      };
-      return callToolFn;
-    },
-  });
-}
+export * from "@decocms/bindings/client";

package/src/state.ts

@@ -1,7 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { z } from "zod";
-import type { AppContext } from "./mastra.ts";
-import { createTool } from "./mastra.ts";
+import { DefaultEnv } from "./index.ts";
+import type { AppContext } from "./tools.ts";
 
 const asyncLocalStorage = new AsyncLocalStorage<AppContext | undefined>();
 
@@ -9,36 +8,9 @@ export const State = {
   getStore: () => {
     return asyncLocalStorage.getStore();
   },
-  run: <TEnv, R, TArgs extends unknown[]>(
+  run: <TEnv extends DefaultEnv, R, TArgs extends unknown[]>(
     ctx: AppContext<TEnv>,
     f: (...args: TArgs) => R,
     ...args: TArgs
   ): R => asyncLocalStorage.run(ctx, f, ...args),
 };
-
-export interface ValidationPayload {
-  state: unknown;
-}
-
-export const createStateValidationTool = (stateSchema?: z.ZodTypeAny) => {
-  return createTool({
-    id: "DECO_CHAT_STATE_VALIDATION",
-    description: "Validate the state of the OAuth flow",
-    inputSchema: z.object({
-      state: z.unknown(),
-    }),
-    outputSchema: z.object({
-      valid: z.boolean(),
-    }),
-    execute: (ctx) => {
-      if (!stateSchema) {
-        return Promise.resolve({ valid: true });
-      }
-      const parsed = stateSchema.safeParse(ctx.context.state);
-      return Promise.resolve({
-        valid: parsed.success,
-        reason: parsed.error?.message,
-      });
-    },
-  });
-};