mtmsdk 0.0.42 → 0.0.43

package/src/index.ts

@@ -0,0 +1,5 @@
+/**
+ * 提示: 禁止导出更多组件, 对于组件引用, 总是使用类似"import { client } from 'mtmsdk/subPackageName/client.gen'" 类似的方式
+ */
+
+export const hello = "hello";

package/src/lib/aisdk/types.ts

@@ -0,0 +1,8 @@
+import type { UIMessage } from "ai";
+
+
+export type AiSdkPart = UIMessage["parts"][number]
+
+// export type MtUIChatMessage = Omit<UIMessage, "role"> & {
+//   role: string;
+// };

package/src/lib/logger/index.ts

@@ -0,0 +1,8 @@
+
+
+/**
+ * 开发提示: 使用 js bind的方式,可以确保最终输出日志定位的文件和调用行号显示为调用方的行号.
+ */
+export const log_info = console.info.bind(console);
+export const log_warn = console.warn.bind(console);
+export const log_error = console.error.bind(console)

package/src/lib/schema.ts

@@ -0,0 +1,50 @@
+import z from "zod";
+
+
+export const zWorkerData = z.object({
+  vncUrl:z.url().optional(),
+  mainApiUrl: z.url().optional(),
+  browserApiUrl: z.url().optional(),
+}).meta({ref: "WorkerData"})
+
+export type WorkerStateData=z.infer<typeof zWorkerData>;
+
+
+export const zDBAgentChatItem = z.object({
+  id: z.string(),
+  title: z.string(),
+  user_id: z.string(),
+  visibility: z.string(),
+  lastContext: z.any().optional(),
+  created_at: z.iso.datetime(),
+  updated_at: z.iso.datetime(),
+}).meta({ref: "DBAgentChatItem"})
+
+export type DBAgentChatItem = z.infer<typeof zDBAgentChatItem>
+
+
+export const zDBChatRow = z.object({
+  id: z.string(),
+  created_at: z.iso.datetime(),
+  updated_at: z.iso.datetime(),
+}).meta({ref: "DBChatRow"})
+
+
+
+export const zDBChatMessage = z.object({
+  id: z.string(),
+  created_at: z.iso.datetime(),
+  updated_at: z.iso.datetime(),
+  chat_id: z.string(),
+  role: z.enum(["user", "assistant", "system", "data", "control"]),
+  parts: z.any(),
+  attachments: z.any(),
+  user_id: z.string()
+}).meta({ref: "ChatMessage"})
+
+export const zDBChatMessageInsertRow = zDBChatMessage.omit({
+  created_at:true,
+  user_id: true,
+}).extend({
+  updated_at: z.iso.datetime().optional(),
+})

package/src/lib/utils.ts

@@ -0,0 +1,54 @@
+// import type { Json } from "../types/database.types";
+
+/**
+ * 提交到 supabase的参数,自动添加前缀'p_', 因为约定所有的后端的 postgresql function的参数都使用"p_"前缀.
+ * @param params Das ursprüngliche Objekt, dessen Schlüssel transformiert werden sollen.
+ * @returns Ein neues Objekt mit den präfigierten Schlüsseln.
+ *
+ * @example
+ * {arg1: "value", arg2: "value2"} => {p_arg1:"value", p_arg2:"value2"}
+ */
+export const normalFuncParams_old = <T extends Record<string, any>>(
+	params: T,
+): { [K in keyof T as `p_${string & K}`]: T[K] } => {
+	const finalParams = {} as { [K in keyof T as `p_${string & K}`]: T[K] };
+	for (const key in params) {
+		if (Object.hasOwn(params, key)) {
+			(finalParams as any)[`p_${key}`] = params[key];
+		}
+	}
+	return finalParams;
+};
+
+export const normalFuncParams = <T extends Record<string, any>>(
+	params: T,
+): { [K in keyof T as `p_${string & K}`]: Exclude<T[K], null> } => {
+	const finalParams = {} as { [K in keyof T as `p_${string & K}`]: Exclude<T[K], null> };
+
+	for (const key in params) {
+		if (Object.hasOwn(params, key)) {
+			const value = params[key];
+			// Wandelt den Wert zur Laufzeit um: null wird zu undefined
+			(finalParams as any)[`p_${key}`] = value === null ? undefined : value;
+		}
+	}
+	return finalParams;
+};
+
+/**
+ * 将可能为null值的字段转换为undefined
+ */
+// export const fieldNullToUndefined = <T extends Record<string, any>>(
+// 	obj: T,
+// ): { [K in keyof T]: T[K] extends null ? undefined : T[K] } => {
+// 	const newObj = { ...obj }; // Erstellt eine flache Kopie, um das Originalobjekt nicht zu verändern
+
+// 	for (const key in newObj) {
+// 		if (Object.hasOwn(newObj, key) && newObj[key] === null) {
+// 			// TypeScript versteht hier, dass der Typ zu 'undefined' geändert wird
+// 			(newObj as any)[key] = undefined;
+// 		}
+// 	}
+
+// 	return newObj as { [K in keyof T]: T[K] extends null ? undefined : T[K] };
+// };

package/src/mtgate_api/@tanstack/react-query.gen.ts

@@ -0,0 +1,175 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { type DefaultError, queryOptions, type UseMutationOptions } from '@tanstack/react-query';
+
+import { client } from '../client.gen';
+import { adkAgentRun, agentChatList, agentChatMessageList, agentQuickAction, agentRun, browserOpen, clawdSessionsList, humanTasksList, mcpApiHello, type Options } from '../sdk.gen';
+import type { AdkAgentRunData, AdkAgentRunResponse, AgentChatListData, AgentChatListResponse, AgentChatMessageListData, AgentChatMessageListResponse, AgentQuickActionData, AgentQuickActionResponse, AgentRunData, AgentRunResponse, BrowserOpenData, BrowserOpenResponse, ClawdSessionsListData, HumanTasksListData, HumanTasksListResponse, McpApiHelloData, McpApiHelloResponse } from '../types.gen';
+
+export const adkAgentRunMutation = (options?: Partial<Options<AdkAgentRunData>>): UseMutationOptions<AdkAgentRunResponse, DefaultError, Options<AdkAgentRunData>> => {
+    const mutationOptions: UseMutationOptions<AdkAgentRunResponse, DefaultError, Options<AdkAgentRunData>> = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await adkAgentRun({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const browserOpenMutation = (options?: Partial<Options<BrowserOpenData>>): UseMutationOptions<BrowserOpenResponse, DefaultError, Options<BrowserOpenData>> => {
+    const mutationOptions: UseMutationOptions<BrowserOpenResponse, DefaultError, Options<BrowserOpenData>> = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await browserOpen({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export type QueryKey<TOptions extends Options> = [
+    Pick<TOptions, 'baseUrl' | 'body' | 'headers' | 'path' | 'query'> & {
+        _id: string;
+        _infinite?: boolean;
+        tags?: ReadonlyArray<string>;
+    }
+];
+
+const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions, infinite?: boolean, tags?: ReadonlyArray<string>): [
+    QueryKey<TOptions>[0]
+] => {
+    const params: QueryKey<TOptions>[0] = { _id: id, baseUrl: options?.baseUrl || (options?.client ?? client).getConfig().baseUrl } as QueryKey<TOptions>[0];
+    if (infinite) {
+        params._infinite = infinite;
+    }
+    if (tags) {
+        params.tags = tags;
+    }
+    if (options?.body) {
+        params.body = options.body;
+    }
+    if (options?.headers) {
+        params.headers = options.headers;
+    }
+    if (options?.path) {
+        params.path = options.path;
+    }
+    if (options?.query) {
+        params.query = options.query;
+    }
+    return [params];
+};
+
+export const agentChatListQueryKey = (options?: Options<AgentChatListData>) => createQueryKey('agentChatList', options);
+
+export const agentChatListOptions = (options?: Options<AgentChatListData>) => queryOptions<AgentChatListResponse, DefaultError, AgentChatListResponse, ReturnType<typeof agentChatListQueryKey>>({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await agentChatList({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentChatListQueryKey(options)
+});
+
+export const agentRunMutation = (options?: Partial<Options<AgentRunData>>): UseMutationOptions<AgentRunResponse, DefaultError, Options<AgentRunData>> => {
+    const mutationOptions: UseMutationOptions<AgentRunResponse, DefaultError, Options<AgentRunData>> = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await agentRun({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const agentQuickActionQueryKey = (options?: Options<AgentQuickActionData>) => createQueryKey('agentQuickAction', options);
+
+export const agentQuickActionOptions = (options?: Options<AgentQuickActionData>) => queryOptions<AgentQuickActionResponse, DefaultError, AgentQuickActionResponse, ReturnType<typeof agentQuickActionQueryKey>>({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await agentQuickAction({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentQuickActionQueryKey(options)
+});
+
+export const agentChatMessageListQueryKey = (options: Options<AgentChatMessageListData>) => createQueryKey('agentChatMessageList', options);
+
+export const agentChatMessageListOptions = (options: Options<AgentChatMessageListData>) => queryOptions<AgentChatMessageListResponse, DefaultError, AgentChatMessageListResponse, ReturnType<typeof agentChatMessageListQueryKey>>({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await agentChatMessageList({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentChatMessageListQueryKey(options)
+});
+
+export const humanTasksListQueryKey = (options?: Options<HumanTasksListData>) => createQueryKey('humanTasksList', options);
+
+export const humanTasksListOptions = (options?: Options<HumanTasksListData>) => queryOptions<HumanTasksListResponse, DefaultError, HumanTasksListResponse, ReturnType<typeof humanTasksListQueryKey>>({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await humanTasksList({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: humanTasksListQueryKey(options)
+});
+
+export const mcpApiHelloQueryKey = (options: Options<McpApiHelloData>) => createQueryKey('mcpApiHello', options);
+
+export const mcpApiHelloOptions = (options: Options<McpApiHelloData>) => queryOptions<McpApiHelloResponse, DefaultError, McpApiHelloResponse, ReturnType<typeof mcpApiHelloQueryKey>>({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await mcpApiHello({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: mcpApiHelloQueryKey(options)
+});
+
+export const clawdSessionsListQueryKey = (options?: Options<ClawdSessionsListData>) => createQueryKey('clawdSessionsList', options);
+
+/**
+ * List clawd sessions via WebSocket proxy using Gateway Protocol
+ */
+export const clawdSessionsListOptions = (options?: Options<ClawdSessionsListData>) => queryOptions<unknown, DefaultError, unknown, ReturnType<typeof clawdSessionsListQueryKey>>({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await clawdSessionsList({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: clawdSessionsListQueryKey(options)
+});

package/src/mtgate_api/client/client.gen.ts

@@ -0,0 +1,311 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createSseClient } from '../core/serverSentEvents.gen';
+import type { HttpMethod } from '../core/types.gen';
+import { getValidRequestBody } from '../core/utils.gen';
+import type {
+  Client,
+  Config,
+  RequestOptions,
+  ResolvedRequestOptions,
+} from './types.gen';
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  getParseAs,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from './utils.gen';
+
+type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
+  body?: any;
+  headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    return getConfig();
+  };
+
+  const interceptors = createInterceptors<
+    Request,
+    Response,
+    unknown,
+    ResolvedRequestOptions
+  >();
+
+  const beforeRequest = async (options: RequestOptions) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined,
+    };
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.body === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
+    }
+
+    const url = buildUrl(opts);
+
+    return { opts, url };
+  };
+
+  const request: Client['request'] = async (options) => {
+    // @ts-expect-error
+    const { opts, url } = await beforeRequest(options);
+    const requestInit: ReqInit = {
+      redirect: 'follow',
+      ...opts,
+      body: getValidRequestBody(opts),
+    };
+
+    let request = new Request(url, requestInit);
+
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request = await fn(request, opts);
+      }
+    }
+
+    // fetch must be assigned here, otherwise it would throw the error:
+    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+    const _fetch = opts.fetch!;
+    let response: Response;
+
+    try {
+      response = await _fetch(request);
+    } catch (error) {
+      // Handle fetch exceptions (AbortError, network errors, etc.)
+      let finalError = error;
+
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = (await fn(
+            error,
+            undefined as any,
+            request,
+            opts,
+          )) as unknown;
+        }
+      }
+
+      finalError = finalError || ({} as unknown);
+
+      if (opts.throwOnError) {
+        throw finalError;
+      }
+
+      // Return error response
+      return opts.responseStyle === 'data'
+        ? undefined
+        : {
+            error: finalError,
+            request,
+            response: undefined as any,
+          };
+    }
+
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request, opts);
+      }
+    }
+
+    const result = {
+      request,
+      response,
+    };
+
+    if (response.ok) {
+      const parseAs =
+        (opts.parseAs === 'auto'
+          ? getParseAs(response.headers.get('Content-Type'))
+          : opts.parseAs) ?? 'json';
+
+      if (
+        response.status === 204 ||
+        response.headers.get('Content-Length') === '0'
+      ) {
+        let emptyData: any;
+        switch (parseAs) {
+          case 'arrayBuffer':
+          case 'blob':
+          case 'text':
+            emptyData = await response[parseAs]();
+            break;
+          case 'formData':
+            emptyData = new FormData();
+            break;
+          case 'stream':
+            emptyData = response.body;
+            break;
+          case 'json':
+          default:
+            emptyData = {};
+            break;
+        }
+        return opts.responseStyle === 'data'
+          ? emptyData
+          : {
+              data: emptyData,
+              ...result,
+            };
+      }
+
+      let data: any;
+      switch (parseAs) {
+        case 'arrayBuffer':
+        case 'blob':
+        case 'formData':
+        case 'text':
+          data = await response[parseAs]();
+          break;
+        case 'json': {
+          // Some servers return 200 with no Content-Length and empty body.
+          // response.json() would throw; read as text and parse if non-empty.
+          const text = await response.text();
+          data = text ? JSON.parse(text) : {};
+          break;
+        }
+        case 'stream':
+          return opts.responseStyle === 'data'
+            ? response.body
+            : {
+                data: response.body,
+                ...result,
+              };
+      }
+
+      if (parseAs === 'json') {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+
+      return opts.responseStyle === 'data'
+        ? data
+        : {
+            data,
+            ...result,
+          };
+    }
+
+    const textError = await response.text();
+    let jsonError: unknown;
+
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+      // noop
+    }
+
+    const error = jsonError ?? textError;
+    let finalError = error;
+
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = (await fn(error, response, request, opts)) as string;
+      }
+    }
+
+    finalError = finalError || ({} as string);
+
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+
+    // TODO: we probably want to return error and improve types
+    return opts.responseStyle === 'data'
+      ? undefined
+      : {
+          error: finalError,
+          ...result,
+        };
+  };
+
+  const makeMethodFn =
+    (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+      request({ ...options, method });
+
+  const makeSseFn =
+    (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+      const { opts, url } = await beforeRequest(options);
+      return createSseClient({
+        ...opts,
+        body: opts.body as BodyInit | null | undefined,
+        headers: opts.headers as unknown as Record<string, string>,
+        method,
+        onRequest: async (url, init) => {
+          let request = new Request(url, init);
+          for (const fn of interceptors.request.fns) {
+            if (fn) {
+              request = await fn(request, opts);
+            }
+          }
+          return request;
+        },
+        serializedBody: getValidRequestBody(opts) as
+          | BodyInit
+          | null
+          | undefined,
+        url,
+      });
+    };
+
+  return {
+    buildUrl,
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
+    getConfig,
+    head: makeMethodFn('HEAD'),
+    interceptors,
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn('CONNECT'),
+      delete: makeSseFn('DELETE'),
+      get: makeSseFn('GET'),
+      head: makeSseFn('HEAD'),
+      options: makeSseFn('OPTIONS'),
+      patch: makeSseFn('PATCH'),
+      post: makeSseFn('POST'),
+      put: makeSseFn('PUT'),
+      trace: makeSseFn('TRACE'),
+    },
+    trace: makeMethodFn('TRACE'),
+  } as Client;
+};

package/src/mtgate_api/client/index.ts

@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export { createClient } from './client.gen';
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';