@super_studio/ecforce-ai-agent-server 1.2.0 → 1.3.0-canary.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super_studio/ecforce-ai-agent-server",
-  "version": "1.2.0",
+  "version": "1.3.0-canary.0",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
@@ -18,6 +18,10 @@
       "require": "./dist/mcp-auth.cjs",
       "import": "./dist/mcp-auth.mjs"
     },
+    "./provider": {
+      "require": "./dist/provider.cjs",
+      "import": "./dist/provider.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -28,6 +32,10 @@
     "swagger-typescript-api": "13.2.9"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.68",
+    "@ai-sdk/google-vertex": "^4.0.106",
+    "@ai-sdk/openai": "^3.0.49",
+    "@ai-sdk/provider": "^3.0.8",
     "@panva/hkdf": "^1.2.1",
     "jose": "^6.0.6"
   },

package/src/lib/constants.ts

@@ -1 +1 @@
-export const API_ENDPOINT = "http://localhost:4043";
+export const API_ENDPOINT = "https://agent.ec-force.com";

package/src/lib/google-proxy-fetch.ts

@@ -0,0 +1,64 @@
+export function createGoogleProxyFetch(apiKey: string | undefined) {
+  return async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = typeof input === "string" ? input : input.toString();
+    const headers = new Headers(init?.headers);
+    headers.delete("x-goog-api-key");
+    headers.delete("X-Goog-Api-Key");
+
+    if (apiKey) {
+      headers.set("authorization", `Bearer ${apiKey}`);
+    }
+
+    const body = normalizeGoogleProxyRequestBody(url, init?.body);
+
+    return fetch(input, {
+      ...init,
+      ...(body ? { body } : {}),
+      headers,
+    });
+  };
+}
+
+function normalizeGoogleProxyRequestBody(
+  url: string,
+  body: RequestInit["body"],
+): RequestInit["body"] {
+  if (!body || typeof body !== "string") {
+    return body;
+  }
+
+  if (
+    !url.includes(":generateContent") &&
+    !url.includes(":streamGenerateContent")
+  ) {
+    return body;
+  }
+
+  try {
+    const payload = JSON.parse(body) as Record<string, unknown>;
+    const toolConfig = payload.toolConfig as
+      | Record<string, unknown>
+      | undefined;
+    const functionCallingConfig = toolConfig?.functionCallingConfig as
+      | Record<string, unknown>
+      | undefined;
+
+    if (!functionCallingConfig?.streamFunctionCallArguments) {
+      return body;
+    }
+
+    const {
+      streamFunctionCallArguments: _streamFunctionCallArguments,
+      ...restFunctionCallingConfig
+    } = functionCallingConfig;
+
+    payload.toolConfig = {
+      ...toolConfig,
+      functionCallingConfig: restFunctionCallingConfig,
+    };
+
+    return JSON.stringify(payload);
+  } catch {
+    return body;
+  }
+}

package/src/provider.ts

@@ -0,0 +1,202 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createVertex } from "@ai-sdk/google-vertex";
+import { createOpenAI } from "@ai-sdk/openai";
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import { API_ENDPOINT } from "@/lib/constants";
+import { createGoogleProxyFetch } from "@/lib/google-proxy-fetch";
+
+export type SpstProviderOptions = {
+  projectId: string;
+  email: string;
+  callerApp: string;
+};
+
+export type CreateSpstProviderParams = {
+  apiKey?: string;
+  baseUrl?: string;
+  callerApp: string;
+};
+
+type SpstProviderConfig = Pick<CreateSpstProviderParams, "apiKey" | "baseUrl">;
+type SpstProviderSet = {
+  openai: ReturnType<typeof createOpenAI>;
+  google: ReturnType<typeof createVertex>;
+  anthropic: ReturnType<typeof createAnthropic>;
+};
+type ParsedSpstModelId =
+  | {
+      provider: "openai";
+      proxyModelId: string;
+    }
+  | {
+      provider: "google";
+      proxyModelId: string;
+    }
+  | {
+      provider: "anthropic";
+      proxyModelId: string;
+    };
+
+const spstProviders = createSpstProviders({});
+
+export function spst(modelId: string): LanguageModelV3 {
+  return createSpstLanguageModel(modelId, spstProviders);
+}
+
+export function createSpstProvider(
+  params: CreateSpstProviderParams,
+): typeof spst {
+  const providers = createSpstProviders(params);
+
+  return (modelId: string) => {
+    return createSpstLanguageModel(modelId, providers, params.callerApp);
+  };
+}
+
+function createSpstProviders(config: SpstProviderConfig): SpstProviderSet {
+  const apiKey = config.apiKey ?? process.env.AI_AGENT_API_KEY;
+
+  return {
+    openai: createOpenAI({
+      name: "spst",
+      baseURL: getOpenAIProxyBaseUrl(config.baseUrl),
+      apiKey,
+    }),
+    google: createVertex({
+      apiKey,
+      baseURL: getGoogleProxyBaseUrl(config.baseUrl),
+      fetch: createGoogleProxyFetch(apiKey),
+    }),
+    anthropic: createAnthropic({
+      baseURL: getAnthropicProxyBaseUrl(config.baseUrl),
+      apiKey,
+    }),
+  };
+}
+
+function getResolvedBaseUrl(baseUrl?: string) {
+  const resolvedBaseUrl =
+    baseUrl ?? process.env.AI_AGENT_API_ENDPOINT ?? API_ENDPOINT;
+  return resolvedBaseUrl.replace(/\/$/, "");
+}
+
+function getOpenAIProxyBaseUrl(baseUrl?: string) {
+  return `${getResolvedBaseUrl(baseUrl)}/api/proxy/v1/openai`;
+}
+
+function getGoogleProxyBaseUrl(baseUrl?: string) {
+  return `${getResolvedBaseUrl(baseUrl)}/api/proxy/v1/google`;
+}
+
+function getAnthropicProxyBaseUrl(baseUrl?: string) {
+  return `${getResolvedBaseUrl(baseUrl)}/api/proxy/v1/anthropic`;
+}
+
+function createSpstLanguageModel(
+  modelId: string,
+  providers: SpstProviderSet,
+  defaultCallerApp?: string,
+) {
+  const parsedModelId = parseSpstModelId(modelId);
+
+  switch (parsedModelId.provider) {
+    case "openai":
+      return wrapSpstModel(
+        providers.openai.responses(parsedModelId.proxyModelId),
+        defaultCallerApp,
+      );
+    case "google":
+      return wrapSpstModel(
+        providers.google(parsedModelId.proxyModelId),
+        defaultCallerApp,
+      );
+    case "anthropic":
+      return wrapSpstModel(
+        providers.anthropic(parsedModelId.proxyModelId),
+        defaultCallerApp,
+      );
+  }
+}
+
+function parseSpstModelId(modelId: string): ParsedSpstModelId {
+  if (modelId.startsWith("openai/")) {
+    return {
+      provider: "openai",
+      proxyModelId: modelId,
+    };
+  }
+
+  if (modelId.startsWith("google/")) {
+    return {
+      provider: "google",
+      proxyModelId: modelId.slice("google/".length),
+    };
+  }
+
+  if (modelId.startsWith("anthropic/")) {
+    return {
+      provider: "anthropic",
+      proxyModelId: modelId.slice("anthropic/".length),
+    };
+  }
+
+  if (modelId.includes("/")) {
+    throw new Error(
+      `Provider '${modelId.split("/")[0]}' is not supported by spst() yet.`,
+    );
+  }
+
+  throw new Error(
+    "The spst() helper currently requires an 'openai/<model>', 'google/<model>', or 'anthropic/<model>' model id.",
+  );
+}
+
+function wrapSpstModel(
+  model: LanguageModelV3,
+  defaultCallerApp?: string,
+): LanguageModelV3 {
+  return {
+    specificationVersion: model.specificationVersion,
+    provider: model.provider,
+    modelId: model.modelId,
+    supportedUrls: model.supportedUrls,
+    doGenerate: (options) =>
+      model.doGenerate(withSpstHeaders(options, defaultCallerApp)),
+    doStream: (options) =>
+      model.doStream(withSpstHeaders(options, defaultCallerApp)),
+  };
+}
+
+function withSpstHeaders(
+  options: Parameters<LanguageModelV3["doGenerate"]>[0],
+  defaultCallerApp?: string,
+): Parameters<LanguageModelV3["doGenerate"]>[0] {
+  const spstOptions = options.providerOptions?.spst as
+    | Partial<SpstProviderOptions>
+    | undefined;
+
+  if (!spstOptions) {
+    return options;
+  }
+
+  const callerApp = spstOptions.callerApp ?? defaultCallerApp;
+
+  if (!spstOptions.projectId || !spstOptions.email || !callerApp) {
+    throw new Error(
+      "The spst provider requires projectId, email, and callerApp in providerOptions.spst.",
+    );
+  }
+
+  const { spst: _spst, ...providerOptions } = options.providerOptions ?? {};
+
+  return {
+    ...options,
+    headers: {
+      ...options.headers,
+      "x-spst-project-id": spstOptions.projectId,
+      "x-spst-user-email": spstOptions.email,
+      "x-spst-caller-app": callerApp,
+    },
+    providerOptions,
+  };
+}