@mitralab.io/functions-sdk 0.1.1 → 0.2.0-beta.1

package/dist/index.js

@@ -1,8 +1,15 @@
 // src/client.ts
 import {
+  createAgentTaskSessionManager,
   createSdkCore,
-  encodePathSegment,
-  expectObject
+  encodePathSegment as encodePathSegment2,
+  expectObject,
+  withAgentTaskSessions
+} from "@mitralab.io/sdk-core";
+
+// src/agent-task-sse.ts
+import {
+  encodePathSegment
 } from "@mitralab.io/sdk-core";
 
 // src/errors.ts
@@ -29,74 +36,11 @@ var MitraApiError = class extends Error {
   }
 };
 
-// src/config.ts
-var DEFAULT_TIMEOUT_MS = 1e4;
-function readDefaultEnvironment() {
-  return typeof process === "undefined" ? {} : process.env;
-}
-function requiredValue(value, name) {
-  if (!value?.trim()) {
-    throw new MitraConfigurationError(`${name} is required`);
-  }
-  return value.trim();
-}
-function removeTrailingSlashes(value) {
-  let end = value.length;
-  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
-  return value.slice(0, end);
-}
-function normalizeApiUrl(value) {
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new MitraConfigurationError("apiUrl must be a valid HTTP or HTTPS URL");
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new MitraConfigurationError("apiUrl must be a valid HTTP or HTTPS URL");
-  }
-  if (parsed.username || parsed.password || parsed.search || parsed.hash || value.includes("?") || value.includes("#")) {
-    throw new MitraConfigurationError(
-      "apiUrl must not include credentials, query parameters, or a fragment"
-    );
-  }
-  return removeTrailingSlashes(parsed.toString());
-}
-function resolveConfig(config = {}, environment = readDefaultEnvironment()) {
-  const apiUrl = normalizeApiUrl(
-    requiredValue(config.apiUrl ?? environment.MITRA_API_URL, "apiUrl")
-  );
-  const accessToken = requiredValue(
-    config.accessToken ?? environment.MITRA_PLATFORM_ACCESS_TOKEN,
-    "accessToken"
-  );
-  const appId = requiredValue(config.appId ?? environment.MITRA_APP_ID, "appId");
-  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const fetchImplementation = config.fetch ?? globalThis.fetch;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new MitraConfigurationError("timeoutMs must be a positive number");
-  }
-  if (typeof fetchImplementation !== "function") {
-    throw new MitraConfigurationError("A fetch implementation is required");
-  }
-  const dataSourceId = config.dataSourceId ?? environment.MITRA_DATA_SOURCE_ID;
-  if (dataSourceId !== void 0 && !dataSourceId.trim()) {
-    throw new MitraConfigurationError("dataSourceId must not be empty when provided");
-  }
-  return {
-    apiUrl,
-    accessToken,
-    appId,
-    ...dataSourceId === void 0 ? {} : { dataSourceId: dataSourceId.trim() },
-    timeoutMs,
-    fetch: fetchImplementation
-  };
-}
-
 // src/http-client.ts
 var bearerCredentialPattern = /(\bBearer\s+)\S+/gi;
 function redactText(value, accessToken) {
-  return value.replace(bearerCredentialPattern, "$1[REDACTED]").split(accessToken).join("[REDACTED]");
+  const bearerRedacted = value.replace(bearerCredentialPattern, "$1[REDACTED]");
+  return accessToken ? bearerRedacted.split(accessToken).join("[REDACTED]") : bearerRedacted;
 }
 function redactDetails(value, accessToken) {
   if (typeof value === "string") return redactText(value, accessToken);
@@ -120,11 +64,31 @@ function optionalString(value) {
 function appendQueryParameters(url, params) {
   for (const [key, value] of Object.entries(params)) {
     if (value === void 0) continue;
-    url.searchParams.append(key, typeof value === "string" ? value : value.toString());
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      url.searchParams.append(key, typeof item === "string" ? item : item.toString());
+    }
   }
 }
+function createRequestHeaders(hasBody, customHeaders, authentication) {
+  const safeCustomHeaders = Object.fromEntries(
+    Object.entries(customHeaders ?? {}).filter(
+      ([name]) => !["authorization", "x-app-id"].includes(name.toLowerCase())
+    )
+  );
+  return {
+    Accept: "application/json",
+    ...hasBody ? { "Content-Type": "application/json" } : {},
+    ...safeCustomHeaders,
+    ...authentication.type === "bearer" ? {
+      Authorization: `Bearer ${authentication.accessToken}`,
+      "X-App-Id": authentication.appId
+    } : {}
+  };
+}
 async function parsePayload(response) {
   const text = await response.text();
+  if (response.ok && !text.trim()) return void 0;
   try {
     return JSON.parse(text);
   } catch {
@@ -157,6 +121,7 @@ function createApiError(response, payload, accessToken) {
   });
 }
 var HttpClient = class {
+  #authentication;
   #accessToken;
   baseUrl;
   appId;
@@ -164,30 +129,30 @@ var HttpClient = class {
   fetchImplementation;
   constructor(config) {
     this.baseUrl = config.baseUrl;
-    this.#accessToken = config.accessToken;
-    this.appId = config.appId;
+    this.#authentication = config.authentication;
+    this.#accessToken = config.authentication === "bearer" ? config.accessToken : void 0;
+    this.appId = config.authentication === "bearer" ? config.appId : void 0;
     this.timeoutMs = config.timeoutMs;
     this.fetchImplementation = config.fetch;
   }
   async request(path, options = {}) {
     const url = new URL(`${this.baseUrl}${path}`);
     appendQueryParameters(url, options.params ?? {});
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    const controller = this.timeoutMs === void 0 ? void 0 : new AbortController();
+    const timeout = controller === void 0 ? void 0 : setTimeout(() => controller.abort(), this.timeoutMs);
     const hasBody = options.body !== void 0;
+    const authentication = this.#authentication === "bearer" ? {
+      type: "bearer",
+      accessToken: this.#accessToken,
+      appId: this.appId
+    } : { type: "anonymous" };
     try {
       const response = await this.fetchImplementation(url, {
         method: options.method ?? "GET",
-        headers: {
-          Accept: "application/json",
-          ...hasBody ? { "Content-Type": "application/json" } : {},
-          Authorization: `Bearer ${this.#accessToken}`,
-          "X-App-Id": this.appId,
-          ...options.headers
-        },
+        headers: createRequestHeaders(hasBody, options.headers, authentication),
         ...hasBody ? { body: JSON.stringify(options.body) } : {},
         redirect: "manual",
-        signal: controller.signal
+        ...controller === void 0 ? {} : { signal: controller.signal }
       });
       if (response.status === 204) return void 0;
       const payload = await parsePayload(response);
@@ -195,7 +160,7 @@ var HttpClient = class {
       return payload;
     } catch (error) {
       if (error instanceof MitraApiError) throw error;
-      if (controller.signal.aborted) {
+      if (controller?.signal.aborted) {
         throw new MitraApiError("Mitra request timed out", 0, {
           code: "REQUEST_TIMEOUT",
           retryable: true
@@ -206,7 +171,7 @@ var HttpClient = class {
         retryable: true
       });
     } finally {
-      clearTimeout(timeout);
+      if (timeout !== void 0) clearTimeout(timeout);
     }
   }
   get(path, params) {
@@ -230,17 +195,385 @@ var HttpClient = class {
   }
 };
 
+// src/agent-task-sse.ts
+function invalidResponse(message) {
+  return new MitraApiError(message, 200, {
+    code: "INVALID_RESPONSE",
+    retryable: false
+  });
+}
+function parseAgentTaskEvent(data) {
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    throw invalidResponse("The Agent event stream returned invalid JSON");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw invalidResponse("The Agent event stream returned an invalid event");
+  }
+  const event = value;
+  if (typeof event.type !== "string" || typeof event.timestamp !== "number") {
+    throw invalidResponse("The Agent event stream returned an invalid event");
+  }
+  if (event.sequence !== void 0 && typeof event.sequence !== "number") {
+    throw invalidResponse("The Agent event stream returned an invalid event sequence");
+  }
+  return value;
+}
+function consumeEventBlock(block, observer) {
+  let eventName = "message";
+  const data = [];
+  for (const rawLine of block.split(/\r?\n/)) {
+    const line = rawLine.replace(/^\uFEFF/, "");
+    if (!line || line.startsWith(":")) continue;
+    const separator = line.indexOf(":");
+    const field = separator === -1 ? line : line.slice(0, separator);
+    let value = separator === -1 ? "" : line.slice(separator + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "event") eventName = value;
+    if (field === "data") data.push(value);
+  }
+  if (eventName === "hello" || eventName === "ping") return;
+  if (eventName !== "message" || data.length === 0) return;
+  observer.onEvent(parseAgentTaskEvent(data.join("\n")));
+}
+async function readErrorPayload(response) {
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    return {};
+  }
+}
+var AgentTaskSseEventSource = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async open(taskId, observer, signal, transport) {
+    if (transport === "websocket") {
+      throw new MitraConfigurationError(
+        "WebSocket Agent sessions are not available in the Functions runtime"
+      );
+    }
+    if (signal?.aborted) throw signal.reason ?? new Error("Agent event stream was aborted");
+    const controller = new AbortController();
+    let handshakeTimedOut = false;
+    let intentionallyClosed = false;
+    let disconnected = false;
+    const abortFromCaller = () => controller.abort(signal?.reason);
+    signal?.addEventListener("abort", abortFromCaller, { once: true });
+    const handshakeTimeout = this.config.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+      handshakeTimedOut = true;
+      controller.abort();
+    }, this.config.timeoutMs);
+    const disconnect = (error) => {
+      if (disconnected || intentionallyClosed) return;
+      disconnected = true;
+      observer.onDisconnect(error);
+    };
+    const cleanup = () => signal?.removeEventListener("abort", abortFromCaller);
+    let response;
+    try {
+      const path = encodePathSegment(taskId, "taskId", this.config.errors);
+      response = await this.config.fetch(`${this.config.baseUrl}/api/v1/tasks/${path}/events`, {
+        method: "GET",
+        headers: {
+          Accept: "text/event-stream",
+          Authorization: `Bearer ${this.config.accessToken}`,
+          "X-App-Id": this.config.appId
+        },
+        redirect: "manual",
+        signal: controller.signal
+      });
+    } catch {
+      if (handshakeTimeout !== void 0) clearTimeout(handshakeTimeout);
+      cleanup();
+      if (handshakeTimedOut) {
+        throw new MitraApiError("Mitra Agent event stream handshake timed out", 0, {
+          code: "REQUEST_TIMEOUT",
+          retryable: true
+        });
+      }
+      if (signal?.aborted) throw signal.reason ?? new Error("Agent event stream was aborted");
+      throw new MitraApiError("The Mitra Agent event stream request failed", 0, {
+        code: "NETWORK_ERROR",
+        retryable: true
+      });
+    }
+    if (handshakeTimeout !== void 0) clearTimeout(handshakeTimeout);
+    if (!response.ok) {
+      cleanup();
+      throw createApiError(response, await readErrorPayload(response), this.config.accessToken);
+    }
+    if (!response.body) {
+      cleanup();
+      throw invalidResponse("The Agent event stream response has no body");
+    }
+    const contentType = response.headers.get("Content-Type") ?? "";
+    if (!contentType.toLowerCase().includes("text/event-stream")) {
+      controller.abort();
+      cleanup();
+      throw invalidResponse("The Agent event stream returned an invalid content type");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    void (async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          let boundary = /\r?\n\r?\n/.exec(buffer);
+          while (boundary?.index !== void 0) {
+            consumeEventBlock(buffer.slice(0, boundary.index), observer);
+            buffer = buffer.slice(boundary.index + boundary[0].length);
+            boundary = /\r?\n\r?\n/.exec(buffer);
+          }
+        }
+        buffer += decoder.decode();
+        if (buffer.trim()) consumeEventBlock(buffer, observer);
+        disconnect();
+      } catch (error) {
+        if (!controller.signal.aborted) {
+          controller.abort();
+          await reader.cancel().catch(() => void 0);
+          disconnect(error);
+        }
+      } finally {
+        cleanup();
+        reader.releaseLock();
+      }
+    })();
+    return {
+      close() {
+        if (intentionallyClosed) return;
+        intentionallyClosed = true;
+        cleanup();
+        controller.abort();
+        void reader.cancel().catch(() => void 0);
+      }
+    };
+  }
+};
+
+// src/app-scoped-apps.ts
+function unavailable(operation) {
+  throw new MitraConfigurationError(
+    `apps.${operation} is not available in an app-scoped Functions runtime`
+  );
+}
+function assertCurrentApp(configuredAppId, requestedAppId) {
+  if (requestedAppId !== configuredAppId) {
+    throw new MitraConfigurationError(
+      `Code Studio access is fixed to app ${configuredAppId}; received ${requestedAppId}`
+    );
+  }
+}
+function createAppScopedAppsModule(apps, appId) {
+  const scoped = {
+    async list() {
+      return unavailable("list");
+    },
+    async get(requestedAppId, options) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.get(appId, options);
+    },
+    async create() {
+      return unavailable("create");
+    },
+    async delete(requestedAppId) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.delete(appId);
+    },
+    async update(requestedAppId, input) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.update(appId, input);
+    },
+    async getFiles(requestedAppId) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.getFiles(appId);
+    },
+    async replaceFiles(requestedAppId, files) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.replaceFiles(appId, files);
+    },
+    async mergeFiles(requestedAppId, files) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.mergeFiles(appId, files);
+    },
+    async build(requestedAppId) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.build(appId);
+    },
+    async publish(requestedAppId, options) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.publish(appId, options);
+    },
+    async getDeploy(requestedAppId, deployId) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.getDeploy(appId, deployId);
+    },
+    async getCurrentDeploy(requestedAppId) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.getCurrentDeploy(appId);
+    },
+    async cancelBuild(requestedAppId, deployId) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.cancelBuild(appId, deployId);
+    },
+    async rollback(requestedAppId, targetVersionId) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.rollback(appId, targetVersionId);
+    },
+    async listDeploys(requestedAppId, options) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.listDeploys(appId, options);
+    },
+    async listVersions(requestedAppId, options) {
+      assertCurrentApp(appId, requestedAppId);
+      return apps.listVersions(appId, options);
+    }
+  };
+  return {
+    apps: scoped,
+    currentApp: {
+      get: (options) => scoped.get(appId, options),
+      delete: () => scoped.delete(appId),
+      update: (input) => scoped.update(appId, input),
+      getFiles: () => scoped.getFiles(appId),
+      replaceFiles: (files) => scoped.replaceFiles(appId, files),
+      mergeFiles: (files) => scoped.mergeFiles(appId, files),
+      build: () => scoped.build(appId),
+      publish: (options) => scoped.publish(appId, options),
+      getDeploy: (deployId) => scoped.getDeploy(appId, deployId),
+      getCurrentDeploy: () => scoped.getCurrentDeploy(appId),
+      cancelBuild: (deployId) => scoped.cancelBuild(appId, deployId),
+      rollback: (targetVersionId) => scoped.rollback(appId, targetVersionId),
+      listDeploys: (options) => scoped.listDeploys(appId, options),
+      listVersions: (options) => scoped.listVersions(appId, options)
+    }
+  };
+}
+
+// src/config.ts
+function readDefaultEnvironment() {
+  return typeof process === "undefined" ? {} : process.env;
+}
+function requiredValue(value, name) {
+  if (!value?.trim()) {
+    throw new MitraConfigurationError(`${name} is required`);
+  }
+  return value.trim();
+}
+function removeTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
+  return value.slice(0, end);
+}
+function normalizeApiUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new MitraConfigurationError("apiUrl must be a valid HTTP or HTTPS URL");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new MitraConfigurationError("apiUrl must be a valid HTTP or HTTPS URL");
+  }
+  if (parsed.username || parsed.password || parsed.search || parsed.hash || value.includes("?") || value.includes("#")) {
+    throw new MitraConfigurationError(
+      "apiUrl must not include credentials, query parameters, or a fragment"
+    );
+  }
+  return removeTrailingSlashes(parsed.toString());
+}
+function deriveNativeApiUrl(legacyBaseUrl) {
+  if (legacyBaseUrl === void 0) return void 0;
+  const parsed = new URL(normalizeApiUrl(legacyBaseUrl));
+  parsed.pathname = parsed.pathname.replace(/\/legacy\/?$/, "") || "/";
+  return removeTrailingSlashes(parsed.toString());
+}
+function resolveConfig(config = {}, environment = readDefaultEnvironment()) {
+  const apiUrl = normalizeApiUrl(
+    requiredValue(
+      config.apiUrl ?? environment.MITRA_API_URL ?? deriveNativeApiUrl(environment.MITRA_BASE_URL),
+      "apiUrl"
+    )
+  );
+  const accessToken = requiredValue(
+    config.accessToken ?? environment.MITRA_PLATFORM_ACCESS_TOKEN ?? environment.MITRA_TOKEN,
+    "accessToken"
+  );
+  const appId = requiredValue(
+    config.appId ?? environment.MITRA_APP_ID ?? environment.MITRA_PROJECT_ID,
+    "appId"
+  );
+  const timeoutMs = config.timeoutMs;
+  const fetchImplementation = config.fetch ?? globalThis.fetch;
+  if (timeoutMs !== void 0 && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+    throw new MitraConfigurationError("timeoutMs must be a positive number");
+  }
+  if (typeof fetchImplementation !== "function") {
+    throw new MitraConfigurationError("A fetch implementation is required");
+  }
+  const dataSourceId = config.dataSourceId ?? environment.MITRA_DATA_SOURCE_ID;
+  if (dataSourceId !== void 0 && !dataSourceId.trim()) {
+    throw new MitraConfigurationError("dataSourceId must not be empty when provided");
+  }
+  return {
+    apiUrl,
+    legacyBaseUrl: normalizeApiUrl(config.legacyBaseUrl ?? environment.MITRA_BASE_URL ?? apiUrl),
+    accessToken,
+    appId,
+    ...dataSourceId === void 0 ? {} : { dataSourceId: dataSourceId.trim() },
+    ...timeoutMs === void 0 ? {} : { timeoutMs },
+    fetch: fetchImplementation
+  };
+}
+
+// src/legacy/configure.ts
+import { configureSdkMitra } from "mitra-sdk";
+function configureLegacySdk(config) {
+  configureSdkMitra({
+    baseURL: config.legacyBaseUrl,
+    token: config.accessToken,
+    projectId: config.appId
+  });
+}
+
 // src/client.ts
 var coreErrors = {
   configuration: (message) => new MitraConfigurationError(message),
   invalidResponse: (message) => new MitraApiError(message, 200, { code: "INVALID_RESPONSE", retryable: false })
 };
 var DefaultMitraClient = class {
+  agentConnections;
+  agentCredentials;
+  agents;
+  agentTasks;
+  apps;
   auth;
+  context;
+  currentApp;
+  customQueries;
+  dataSources;
   entities;
   functions;
+  functionsAdmin;
+  imports;
   integration;
+  integrationAdmin;
+  integrationResources;
+  integrationTemplates;
+  members;
+  messenger;
+  publicFunctions;
   queries;
+  schema;
+  sql;
+  workflows;
   #dataSourceId;
   #initPromise;
   #appId;
@@ -250,27 +583,78 @@ var DefaultMitraClient = class {
     this.#dataSourceId = config.dataSourceId;
     const httpClient = (service) => new HttpClient({
       baseUrl: `${config.apiUrl}/${service}`,
+      authentication: "bearer",
       accessToken: config.accessToken,
       appId: config.appId,
-      timeoutMs: config.timeoutMs,
+      ...config.timeoutMs === void 0 ? {} : { timeoutMs: config.timeoutMs },
       fetch: config.fetch
     });
     const core = createSdkCore({
       transports: {
         auth: httpClient("iam"),
+        codeStudio: httpClient("code-studio"),
+        copilot: httpClient("copilot"),
         dataManager: httpClient("data-manager"),
         functions: httpClient("functions"),
-        integration: httpClient("integration")
+        integration: httpClient("integration"),
+        messenger: httpClient("messenger"),
+        publicFunctions: new HttpClient({
+          baseUrl: `${config.apiUrl}/functions`,
+          authentication: "anonymous",
+          ...config.timeoutMs === void 0 ? {} : { timeoutMs: config.timeoutMs },
+          fetch: config.fetch
+        })
       },
-      getDataSourceId: () => this.#dataSourceId,
+      getAppId: () => this.#appId,
       functions: { executeInvocationType: "sync", emptyInput: "empty-object" },
       errors: coreErrors
     });
+    const appModules = createAppScopedAppsModule(core.apps, this.#appId);
+    this.agentConnections = core.agentConnections;
+    this.agentCredentials = core.agentCredentials;
+    this.agents = core.agents;
+    const agentSessionManager = createAgentTaskSessionManager({
+      tasks: core.agentTasks,
+      eventSource: new AgentTaskSseEventSource({
+        baseUrl: `${config.apiUrl}/copilot`,
+        accessToken: config.accessToken,
+        appId: config.appId,
+        ...config.timeoutMs === void 0 ? {} : { timeoutMs: config.timeoutMs },
+        fetch: config.fetch,
+        errors: coreErrors
+      })
+    });
+    this.agentTasks = withAgentTaskSessions(core.agentTasks, {
+      session: (options) => {
+        if (options.transport === "websocket") {
+          throw new MitraConfigurationError(
+            "WebSocket Agent sessions are not available in the Functions runtime; use http or auto"
+          );
+        }
+        return agentSessionManager.session(options);
+      }
+    });
+    this.apps = appModules.apps;
     this.auth = core.auth;
+    this.context = core.context;
+    this.currentApp = appModules.currentApp;
+    this.customQueries = core.customQueries;
+    this.dataSources = core.dataSources;
     this.entities = core.entities;
     this.functions = core.functions;
+    this.functionsAdmin = core.functionsAdmin;
+    this.imports = core.imports;
     this.integration = core.integration;
+    this.integrationAdmin = core.integrationAdmin;
+    this.integrationResources = core.integrationResources;
+    this.integrationTemplates = core.integrationTemplates;
+    this.members = core.members;
+    this.messenger = core.messenger;
+    this.publicFunctions = core.publicFunctions;
     this.queries = core.queries;
+    this.schema = core.schema;
+    this.sql = core.sql;
+    this.workflows = core.workflows;
     this.#codeStudioHttpClient = httpClient("code-studio");
   }
   init() {
@@ -286,12 +670,13 @@ var DefaultMitraClient = class {
   async resolveDataSourceId() {
     const appInfo = expectObject(
       await this.#codeStudioHttpClient.get(
-        `/api/v1/apps/${encodePathSegment(this.#appId, "appId", coreErrors)}/info`
+        `/api/v1/apps/${encodePathSegment2(this.#appId, "appId", coreErrors)}/info`
       ),
       "App info response",
       coreErrors
     );
-    if (!appInfo.dataSourceId?.trim()) {
+    if (appInfo.dataSourceId === null) return;
+    if (typeof appInfo.dataSourceId !== "string" || !appInfo.dataSourceId.trim()) {
       throw new MitraApiError("The app info response does not include a dataSourceId", 200, {
         code: "INVALID_RESPONSE",
         retryable: false
@@ -300,15 +685,148 @@ var DefaultMitraClient = class {
     this.#dataSourceId = appInfo.dataSourceId;
   }
 };
+function createConfiguredClient(config) {
+  configureLegacySdk(config);
+  return new DefaultMitraClient(config);
+}
 function createClient(config = {}) {
-  return new DefaultMitraClient(resolveConfig(config));
+  return createConfiguredClient(resolveConfig(config));
 }
 function createClientFromEnvironment(environment) {
-  return new DefaultMitraClient(resolveConfig({}, environment));
+  return createConfiguredClient(resolveConfig({}, environment));
 }
+
+// src/index.ts
+import { AgentTaskTurnError } from "@mitralab.io/sdk-core";
+
+// src/legacy/index.ts
+import * as legacy from "mitra-sdk";
+var configureSdkMitra3 = legacy.configureSdkMitra;
+var createMitraSdkInstance2 = legacy.createMitraSdkInstance;
+var resolveProjectId2 = legacy.resolveProjectId;
+var createRecordMitra2 = legacy.createRecordMitra;
+var createRecordsBatchMitra2 = legacy.createRecordsBatchMitra;
+var getRecordMitra2 = legacy.getRecordMitra;
+var listRecordsMitra2 = legacy.listRecordsMitra;
+var updateRecordMitra2 = legacy.updateRecordMitra;
+var patchRecordMitra2 = legacy.patchRecordMitra;
+var deleteRecordMitra2 = legacy.deleteRecordMitra;
+var executeServerFunctionMitra2 = legacy.executeServerFunctionMitra;
+var executeServerFunctionAsyncMitra2 = legacy.executeServerFunctionAsyncMitra;
+var getServerFunctionExecutionMitra2 = legacy.getServerFunctionExecutionMitra;
+var stopServerFunctionExecutionMitra2 = legacy.stopServerFunctionExecutionMitra;
+var executePublicServerFunctionAsyncMitra2 = legacy.executePublicServerFunctionAsyncMitra;
+var callIntegrationMitra2 = legacy.callIntegrationMitra;
+var listIntegrationsMitra2 = legacy.listIntegrationsMitra;
+var getProjectsMitra2 = legacy.getProjectsMitra;
+var getProjectContextMitra2 = legacy.getProjectContextMitra;
+var listProjectsMitra2 = legacy.listProjectsMitra;
+var createProjectMitra2 = legacy.createProjectMitra;
+var updateProjectSettingsMitra2 = legacy.updateProjectSettingsMitra;
+var getGitConfigMitra2 = legacy.getGitConfigMitra;
+var createJdbcConnectionMitra2 = legacy.createJdbcConnectionMitra;
+var listJdbcConnectionsMitra2 = legacy.listJdbcConnectionsMitra;
+var updateJdbcConnectionMitra2 = legacy.updateJdbcConnectionMitra;
+var deleteJdbcConnectionMitra2 = legacy.deleteJdbcConnectionMitra;
+var runQueryMitra2 = legacy.runQueryMitra;
+var runDdlMitra2 = legacy.runDdlMitra;
+var runDmlMitra2 = legacy.runDmlMitra;
+var listTablesMitra2 = legacy.listTablesMitra;
+var createOnlineTableMitra2 = legacy.createOnlineTableMitra;
+var listOnlineTablesMitra2 = legacy.listOnlineTablesMitra;
+var updateOnlineTableMitra2 = legacy.updateOnlineTableMitra;
+var deleteOnlineTableMitra2 = legacy.deleteOnlineTableMitra;
+var createServerFunctionMitra2 = legacy.createServerFunctionMitra;
+var readServerFunctionMitra2 = legacy.readServerFunctionMitra;
+var listServerFunctionsMitra2 = legacy.listServerFunctionsMitra;
+var updateServerFunctionMitra2 = legacy.updateServerFunctionMitra;
+var deleteServerFunctionMitra2 = legacy.deleteServerFunctionMitra;
+var togglePublicExecutionMitra2 = legacy.togglePublicExecutionMitra;
+var createIntegrationMitra2 = legacy.createIntegrationMitra;
+var updateIntegrationMitra2 = legacy.updateIntegrationMitra;
+var deleteIntegrationMitra2 = legacy.deleteIntegrationMitra;
+var testIntegrationMitra2 = legacy.testIntegrationMitra;
+var testIntegrationByIdMitra2 = legacy.testIntegrationByIdMitra;
+var listIntegrationTemplatesMitra2 = legacy.listIntegrationTemplatesMitra;
+var getIntegrationTemplateMitra2 = legacy.getIntegrationTemplateMitra;
+var createAgentMitra2 = legacy.createAgentMitra;
+var readAgentMitra2 = legacy.readAgentMitra;
+var listAgentsMitra2 = legacy.listAgentsMitra;
+var updateAgentMitra2 = legacy.updateAgentMitra;
+var deleteAgentMitra2 = legacy.deleteAgentMitra;
+var getAgentTaskMitra2 = legacy.getAgentTaskMitra;
+var manageAgentChatMitra2 = legacy.manageAgentChatMitra;
+var manageAgentCredentialMitra2 = legacy.manageAgentCredentialMitra;
+var manageAgentConnectionMitra2 = legacy.manageAgentConnectionMitra;
+var inviteUserMitra2 = legacy.inviteUserMitra;
+var unsubscribeUserMitra2 = legacy.unsubscribeUserMitra;
+var deployToS3Mitra2 = legacy.deployToS3Mitra;
+var getDeployStatusMitra2 = legacy.getDeployStatusMitra;
 export {
+  AgentTaskTurnError,
   MitraApiError,
   MitraConfigurationError,
+  callIntegrationMitra2 as callIntegrationMitra,
+  configureSdkMitra3 as configureSdkMitra,
+  createAgentMitra2 as createAgentMitra,
   createClient,
-  createClientFromEnvironment
+  createClientFromEnvironment,
+  createIntegrationMitra2 as createIntegrationMitra,
+  createJdbcConnectionMitra2 as createJdbcConnectionMitra,
+  createMitraSdkInstance2 as createMitraSdkInstance,
+  createOnlineTableMitra2 as createOnlineTableMitra,
+  createProjectMitra2 as createProjectMitra,
+  createRecordMitra2 as createRecordMitra,
+  createRecordsBatchMitra2 as createRecordsBatchMitra,
+  createServerFunctionMitra2 as createServerFunctionMitra,
+  deleteAgentMitra2 as deleteAgentMitra,
+  deleteIntegrationMitra2 as deleteIntegrationMitra,
+  deleteJdbcConnectionMitra2 as deleteJdbcConnectionMitra,
+  deleteOnlineTableMitra2 as deleteOnlineTableMitra,
+  deleteRecordMitra2 as deleteRecordMitra,
+  deleteServerFunctionMitra2 as deleteServerFunctionMitra,
+  deployToS3Mitra2 as deployToS3Mitra,
+  executePublicServerFunctionAsyncMitra2 as executePublicServerFunctionAsyncMitra,
+  executeServerFunctionAsyncMitra2 as executeServerFunctionAsyncMitra,
+  executeServerFunctionMitra2 as executeServerFunctionMitra,
+  getAgentTaskMitra2 as getAgentTaskMitra,
+  getDeployStatusMitra2 as getDeployStatusMitra,
+  getGitConfigMitra2 as getGitConfigMitra,
+  getIntegrationTemplateMitra2 as getIntegrationTemplateMitra,
+  getProjectContextMitra2 as getProjectContextMitra,
+  getProjectsMitra2 as getProjectsMitra,
+  getRecordMitra2 as getRecordMitra,
+  getServerFunctionExecutionMitra2 as getServerFunctionExecutionMitra,
+  inviteUserMitra2 as inviteUserMitra,
+  listAgentsMitra2 as listAgentsMitra,
+  listIntegrationTemplatesMitra2 as listIntegrationTemplatesMitra,
+  listIntegrationsMitra2 as listIntegrationsMitra,
+  listJdbcConnectionsMitra2 as listJdbcConnectionsMitra,
+  listOnlineTablesMitra2 as listOnlineTablesMitra,
+  listProjectsMitra2 as listProjectsMitra,
+  listRecordsMitra2 as listRecordsMitra,
+  listServerFunctionsMitra2 as listServerFunctionsMitra,
+  listTablesMitra2 as listTablesMitra,
+  manageAgentChatMitra2 as manageAgentChatMitra,
+  manageAgentConnectionMitra2 as manageAgentConnectionMitra,
+  manageAgentCredentialMitra2 as manageAgentCredentialMitra,
+  patchRecordMitra2 as patchRecordMitra,
+  readAgentMitra2 as readAgentMitra,
+  readServerFunctionMitra2 as readServerFunctionMitra,
+  resolveProjectId2 as resolveProjectId,
+  runDdlMitra2 as runDdlMitra,
+  runDmlMitra2 as runDmlMitra,
+  runQueryMitra2 as runQueryMitra,
+  stopServerFunctionExecutionMitra2 as stopServerFunctionExecutionMitra,
+  testIntegrationByIdMitra2 as testIntegrationByIdMitra,
+  testIntegrationMitra2 as testIntegrationMitra,
+  togglePublicExecutionMitra2 as togglePublicExecutionMitra,
+  unsubscribeUserMitra2 as unsubscribeUserMitra,
+  updateAgentMitra2 as updateAgentMitra,
+  updateIntegrationMitra2 as updateIntegrationMitra,
+  updateJdbcConnectionMitra2 as updateJdbcConnectionMitra,
+  updateOnlineTableMitra2 as updateOnlineTableMitra,
+  updateProjectSettingsMitra2 as updateProjectSettingsMitra,
+  updateRecordMitra2 as updateRecordMitra,
+  updateServerFunctionMitra2 as updateServerFunctionMitra
 };