@svadmin/core 0.50.0 → 0.53.0

package/src/task-hooks.svelte.ts

@@ -1,16 +1,21 @@
-import { createMutation, createQuery, useQueryClient } from '@tanstack/svelte-query';
+import { definedOptions } from './defined-options';
+import { createMutation,useQueryClient } from '@tanstack/svelte-query';
+import { createSessionQuery } from './session-query.svelte';
+import { supersededQuerySession } from './query-session.svelte';
 import { getAdminOptions } from './options.svelte';
 import { captureAdminContext } from './context.svelte';
 import type { AdminContextAccessor } from './context.svelte';
 import {
   resolveTenantProviderMeta,
 } from './provider-bundle';
-import { queryKeyMatches } from './query-keys';
-import { checkError, createOvertimeTracker, fireErrorNotification, fireSuccessNotification } from './hook-utils.svelte';
-import type { NotificationConfig, OvertimeOptions } from './hook-utils.svelte';
+import { queryKeyMatches, type QueryKey } from './query-keys';
+import { replaceReactiveMembers } from './reactive-projection';
+import { taskQueryParams, withValidatedTaskProvider } from './task-provider';
+import { TaskError, decodeTaskRecord, decodeTaskList } from './task-contract';
+import { checkError,createOvertimeTracker,fireErrorNotification,fireSuccessNotification } from './hook-utils.svelte';
+import type { NotificationConfig,OvertimeOptions } from './hook-utils.svelte';
 import { useTranslation } from './i18n.svelte';
 import type {
-  HttpError,
   SubmitTaskOptions,
   TaskHandle,
   TaskListResult,
@@ -18,100 +23,141 @@ import type {
   TaskRecord,
 } from './types';
 
-function normalizeTaskProvider<TTask extends TaskRecord = TaskRecord>(
-  provider?: TaskProvider<TTask>,
-  adminContext: AdminContextAccessor = captureAdminContext(),
-): TaskProvider<TTask> {
-  const activeProvider = provider ?? adminContext.taskProvider;
-  if (!activeProvider) {
+function normalizeTaskProvider(
+  provider?: TaskProvider,
+  adminContext: AdminContextAccessor=captureAdminContext(),
+): TaskProvider {
+  const activeProvider=provider??adminContext.taskProvider;
+  if(!activeProvider) {
     throw new Error('TaskProvider not found. Did you call setTaskProvider in App.svelte?');
   }
-  return activeProvider as TaskProvider<TTask>;
+  return withValidatedTaskProvider(activeProvider);
+}
+
+const providerKeys = new WeakMap<TaskProvider, number>();
+let nextProviderKey = 0;
+function taskProviderKey(provider: TaskProvider | undefined): number {
+  if (!provider) return 0;
+  let providerKey = providerKeys.get(provider);
+  if (providerKey === undefined) {
+    providerKey = ++nextProviderKey;
+    providerKeys.set(provider, providerKey);
+  }
+  return providerKey;
+}
+function scopedTaskKey(key: QueryKey, provider: TaskProvider | undefined): QueryKey {
+  const providerKey = taskProviderKey(provider);
+  return [{ ...key[0], params: definedOptions({ taskProvider: providerKey, query: key[0].params }) }];
+}
+
+function taskReadError(error: unknown): Error {
+  try {
+    if (typeof error === 'object' && error !== null) {
+      const code: unknown = Object.getOwnPropertyDescriptor(error, 'code')?.value;
+      if (code === 'QUERY_SESSION_SUPERSEDED') return supersededQuerySession();
+      if (code === 'INVALID_TASK_INPUT' || code === 'INVALID_TASK_RESPONSE' || code === 'TASK_PROVIDER_FAILED') {
+        return new TaskError(code);
+      }
+    }
+  } catch { /* 不执行错误对象中的 getter，也不回显上游诊断。 */ }
+  return new TaskError('TASK_PROVIDER_FAILED');
 }
 
 export interface UseSubmitTaskOptions {
   mutationOptions?: {
-    onSuccess?: (data: unknown, variables: unknown, context: unknown) => void;
-    onError?: (error: unknown, variables: unknown, context: unknown) => void;
+    onSuccess?: (data: unknown,variables: unknown,context: unknown) => void;
+    onError?: (error: unknown,variables: unknown,context: unknown) => void;
   };
   overtimeOptions?: OvertimeOptions;
 }
 
-export interface UseSubmitTaskMutateParams<TTask extends TaskRecord = TaskRecord> {
+export interface UseSubmitTaskMutateParams {
   taskName: string;
   options?: SubmitTaskOptions;
-  taskProvider?: TaskProvider<TTask>;
+  taskProvider?: TaskProvider;
   successNotification?: NotificationConfig;
   errorNotification?: NotificationConfig;
 }
 
-export function useSubmitTask<
-  TTask extends TaskRecord = TaskRecord,
-  TError = HttpError,
->(options: UseSubmitTaskOptions = {}) {
-  const adminContext = captureAdminContext();
-  const i18n = useTranslation();
-  const adminOptions = getAdminOptions();
-  const queryClient = useQueryClient();
-  const overtime = createOvertimeTracker(() => mutation.isPending, options.overtimeOptions ?? adminOptions.overtime);
+export function useSubmitTask(options: UseSubmitTaskOptions={}) {
+  const adminContext=captureAdminContext();
+  const i18n=useTranslation();
+  const adminOptions=getAdminOptions();
+  const queryClient=useQueryClient();
+  const overtime=createOvertimeTracker(() => mutation.isPending,options.overtimeOptions??adminOptions.overtime);
+  const submissionScopes = new WeakMap<TaskHandle, ReturnType<AdminContextAccessor['queryKeyMatcher']>>();
 
-  const mutation = createMutation<TaskHandle<TTask>, TError, UseSubmitTaskMutateParams<TTask>>(() => ({
+  const mutation=createMutation<TaskHandle,Error,UseSubmitTaskMutateParams>(() => ({
     mutationFn: async (params) => {
-      const provider = normalizeTaskProvider<TTask>(params.taskProvider, adminContext);
-      const providerMeta = adminContext.tenant
+      const scope = adminContext.queryKeyMatcher();
+      const provider=normalizeTaskProvider(params.taskProvider,adminContext);
+      const providerMeta=adminContext.tenant
         ? {
-            ...(params.options?.meta ?? {}),
-            ...resolveTenantProviderMeta(adminContext.tenant, adminContext.tenantAdapter),
-          }
-        : params.options?.meta;
-      const taskOptions = providerMeta === params.options?.meta
+          ...(params.options?.meta??{}),
+          ...resolveTenantProviderMeta(adminContext.tenant,adminContext.tenantAdapter),
+        }
+        :params.options?.meta;
+      const taskOptions=providerMeta===params.options?.meta
         ? params.options
-        : { ...params.options, meta: providerMeta };
-      return provider.submit(params.taskName, taskOptions);
+        :definedOptions({
+          ...params.options,
+          meta: providerMeta,
+        });
+      const handle = await provider.submit(params.taskName,taskOptions);
+      submissionScopes.set(handle, scope);
+      return handle;
     },
-    onSuccess: (data, params, context) => {
+    onSuccess: (data,params,context) => {
       fireSuccessNotification({
         config: params.successNotification,
         defaultMessage: i18n.t('task.submitSuccess'),
         data,
         values: params.options,
         resource: params.taskName,
-        provider: adminContext.notificationProvider,
-      });
-      void queryClient.invalidateQueries({
-        predicate: (query) => queryKeyMatches(query.queryKey, {
-          ...adminContext.queryKeyMatcher(),
-          kind: 'task',
-          action: 'list',
-        }),
+        ...definedOptions({
+          provider: adminContext.notificationProvider
+        })
       });
-      options.mutationOptions?.onSuccess?.(data, params, context);
+      const scope = submissionScopes.get(data);
+      if (scope) {
+        submissionScopes.delete(data);
+        void queryClient.invalidateQueries({
+          predicate: (query) => queryKeyMatches(query.queryKey,{
+            ...scope,
+            kind: 'task',
+            action: 'list',
+          }),
+        });
+      }
+      options.mutationOptions?.onSuccess?.(data,params,context);
     },
-    onError: (error, params, context) => {
-      checkError(error, adminContext);
+    onError: (error,params,context) => {
+      checkError(error,adminContext);
       fireErrorNotification({
         config: params.errorNotification,
         defaultMessage: i18n.t('task.submitFailed'),
         error,
         resource: params.taskName,
-        provider: adminContext.notificationProvider,
+        ...definedOptions({
+          provider: adminContext.notificationProvider
+        })
       });
-      options.mutationOptions?.onError?.(error, params, context);
+      options.mutationOptions?.onError?.(error,params,context);
     },
   }));
 
-  return { mutation, get overtime() { return overtime; } };
+  return { mutation,get overtime() { return overtime; } };
 }
 
-export interface UseTaskOptions<TTask extends TaskRecord = TaskRecord, _TError = HttpError> {
+export interface UseTaskOptions {
   taskId?: string;
-  taskProvider?: TaskProvider<TTask>;
+  taskProvider?: TaskProvider;
   queryOptions?: {
     enabled?: boolean;
     staleTime?: number;
     gcTime?: number;
     refetchOnWindowFocus?: boolean;
-    refetchInterval?: number | false;
+    refetchInterval?: number|false;
     refetchIntervalInBackground?: boolean;
   };
   successNotification?: NotificationConfig;
@@ -119,78 +165,58 @@ export interface UseTaskOptions<TTask extends TaskRecord = TaskRecord, _TError =
   overtimeOptions?: OvertimeOptions;
 }
 
-export function useTask<TTask extends TaskRecord = TaskRecord, TError = HttpError>(
-  options: UseTaskOptions<TTask, TError> = {},
+export function useTask(
+  options: UseTaskOptions={},
 ) {
-  const adminContext = captureAdminContext();
-  const i18n = useTranslation();
-  const adminOptions = getAdminOptions();
+  const adminContext=captureAdminContext();
+  const i18n=useTranslation();
+  const adminOptions=getAdminOptions();
 
-  const query = createQuery<TTask, TError>(() => {
-    const provider = normalizeTaskProvider<TTask>(options.taskProvider, adminContext);
-    const queryOptions = options.queryOptions;
+  const query=createSessionQuery<TaskRecord>(adminContext, () => {
+    const activeProvider=options.taskProvider??adminContext.taskProvider;
+    const provider=activeProvider? withValidatedTaskProvider(activeProvider):undefined;
+    const taskId=options.taskId;
+    const queryOptions=options.queryOptions;
     return {
-      queryKey: adminContext.queryKeys().task.one(options.taskId ?? ''),
+      resource: taskId ?? '',
+      successNotification: options.successNotification,
+      errorNotification: options.errorNotification ?? i18n.t('task.fetchFailed'),
+      normalizeError: taskReadError,
+      decode: value => decodeTaskRecord(value, taskId),
+      queryKey: scopedTaskKey(adminContext.queryKeys().task.one(taskId??''),provider),
       queryFn: async () => {
-        if (!options.taskId) throw new Error('useTask requires a taskId');
-        return provider.get(options.taskId);
+        if(!provider) throw new Error('TaskProvider not found.');
+        if(!taskId) throw new Error('useTask requires a taskId');
+        return provider.get(taskId);
       },
-      enabled: (queryOptions?.enabled ?? true) && !!options.taskId,
-      staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-      gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
-      refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
-      refetchInterval: queryOptions?.refetchInterval,
-      refetchIntervalInBackground: queryOptions?.refetchIntervalInBackground,
+      enabled: (queryOptions?.enabled??true)&&!!taskId,
+      ...definedOptions({
+        staleTime: queryOptions?.staleTime??adminOptions.reactQuery?.staleTime,
+        gcTime: queryOptions?.gcTime??adminOptions.reactQuery?.gcTime,
+        refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus??adminOptions.reactQuery?.refetchOnWindowFocus,
+      }),
+      ...definedOptions({
+        refetchInterval: queryOptions?.refetchInterval,
+        refetchIntervalInBackground: queryOptions?.refetchIntervalInBackground,
+      }),
     };
   });
 
-  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
-
-  let lastSuccessAt = 0;
-  let lastErrorAt = 0;
-  $effect(() => {
-    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
-      lastSuccessAt = query.dataUpdatedAt;
-      if (options.successNotification) {
-        fireSuccessNotification({
-          config: options.successNotification,
-          defaultMessage: '',
-          data: query.data,
-          resource: options.taskId,
-          provider: adminContext.notificationProvider,
-        });
-      }
-    } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
-      lastErrorAt = query.errorUpdatedAt;
-      checkError(query.error, adminContext);
-      fireErrorNotification({
-        config: options.errorNotification,
-        defaultMessage: i18n.t('task.fetchFailed'),
-        error: query.error,
-        resource: options.taskId,
-        provider: adminContext.notificationProvider,
-      });
-    }
-  });
+  const overtime=createOvertimeTracker(() => query.isLoading,options.overtimeOptions??adminOptions.overtime);
 
-  return new Proxy(query, {
-    get(target, prop) {
-      if (prop === 'overtime') return overtime;
-      return target[prop as keyof typeof target];
-    },
-  }) as typeof query & { overtime: typeof overtime };
+  return replaceReactiveMembers(query,{ get overtime() { return overtime; } });
 }
 
-export interface UseTaskListOptions<TTask extends TaskRecord = TaskRecord, _TError = HttpError> {
-  params?: Record<string, unknown>;
+export interface UseTaskListOptions {
+  params?: Record<string,unknown>;
   dlq?: boolean;
-  taskProvider?: TaskProvider<TTask>;
+  taskProvider?: TaskProvider;
   queryOptions?: {
     enabled?: boolean;
     staleTime?: number;
     gcTime?: number;
     refetchOnWindowFocus?: boolean;
-    refetchInterval?: number | false;
+    refetchInterval?: number|false;
     refetchIntervalInBackground?: boolean;
   };
   successNotification?: NotificationConfig;
@@ -198,104 +224,88 @@ export interface UseTaskListOptions<TTask extends TaskRecord = TaskRecord, _TErr
   overtimeOptions?: OvertimeOptions;
 }
 
-export function useTaskList<TTask extends TaskRecord = TaskRecord, TError = HttpError>(
-  options: UseTaskListOptions<TTask, TError> = {},
+export function useTaskList(
+  options: UseTaskListOptions={},
 ) {
-  const adminContext = captureAdminContext();
-  const i18n = useTranslation();
-  const adminOptions = getAdminOptions();
+  const adminContext=captureAdminContext();
+  const i18n=useTranslation();
+  const adminOptions=getAdminOptions();
 
-  const query = createQuery<TaskListResult<TTask>, TError>(() => {
-    const provider = normalizeTaskProvider<TTask>(options.taskProvider, adminContext);
-    const queryOptions = options.queryOptions;
+  const query=createSessionQuery<TaskListResult>(adminContext, () => {
+    const activeProvider=options.taskProvider??adminContext.taskProvider;
+    const provider=activeProvider? withValidatedTaskProvider(activeProvider):undefined;
+    const params=options.params===undefined? undefined:taskQueryParams(options.params);
+    const dlq=options.dlq??false;
+    const queryOptions=options.queryOptions;
+    const resource = dlq ? 'taskDlq' : 'tasks';
+    const successNotification = options.successNotification;
     return {
-      queryKey: adminContext.queryKeys().task.list({
-        list: options.dlq ? 'dlq' : 'default',
-        params: options.params,
-      }),
+      resource,
+      successNotification: typeof successNotification === 'function'
+        ? (data: unknown) => successNotification(data, params, resource)
+        : successNotification,
+      errorNotification: options.errorNotification ?? i18n.t('task.fetchListFailed'),
+      normalizeError: taskReadError,
+      decode: decodeTaskList,
+      queryKey: scopedTaskKey(adminContext.queryKeys().task.list(definedOptions({
+        list: dlq? 'dlq':'default',
+        params,
+      })),provider),
       queryFn: async () => {
-        if (options.dlq) {
-          if (!provider.listDlq) throw new Error('TaskProvider does not implement listDlq');
-          return provider.listDlq(options.params);
+        if(!provider) throw new Error('TaskProvider not found.');
+        if(dlq) {
+          if(!provider.listDlq) throw new Error('TaskProvider does not implement listDlq');
+          return provider.listDlq(params);
         }
-        if (!provider.list) throw new Error('TaskProvider does not implement list');
-        return provider.list(options.params);
+        if(!provider.list) throw new Error('TaskProvider does not implement list');
+        return provider.list(params);
       },
-      enabled: queryOptions?.enabled ?? true,
-      staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-      gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
-      refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
-      refetchInterval: queryOptions?.refetchInterval,
-      refetchIntervalInBackground: queryOptions?.refetchIntervalInBackground,
+      enabled: queryOptions?.enabled??true,
+      ...definedOptions({
+        staleTime: queryOptions?.staleTime??adminOptions.reactQuery?.staleTime,
+        gcTime: queryOptions?.gcTime??adminOptions.reactQuery?.gcTime,
+        refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus??adminOptions.reactQuery?.refetchOnWindowFocus,
+      }),
+      ...definedOptions({
+        refetchInterval: queryOptions?.refetchInterval,
+        refetchIntervalInBackground: queryOptions?.refetchIntervalInBackground,
+      }),
     };
   });
 
-  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
+  const overtime=createOvertimeTracker(() => query.isLoading,options.overtimeOptions??adminOptions.overtime);
 
-  let lastSuccessAt = 0;
-  let lastErrorAt = 0;
-  $effect(() => {
-    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
-      lastSuccessAt = query.dataUpdatedAt;
-      if (options.successNotification) {
-        fireSuccessNotification({
-          config: options.successNotification,
-          defaultMessage: '',
-          data: query.data,
-          values: options.params,
-          resource: options.dlq ? 'taskDlq' : 'tasks',
-          provider: adminContext.notificationProvider,
-        });
-      }
-    } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
-      lastErrorAt = query.errorUpdatedAt;
-      checkError(query.error, adminContext);
-      fireErrorNotification({
-        config: options.errorNotification,
-        defaultMessage: i18n.t('task.fetchListFailed'),
-        error: query.error,
-        resource: options.dlq ? 'taskDlq' : 'tasks',
-        provider: adminContext.notificationProvider,
-      });
-    }
-  });
-
-  return new Proxy(query, {
-    get(target, prop) {
-      if (prop === 'overtime') return overtime;
-      return target[prop as keyof typeof target];
-    },
-  }) as typeof query & { overtime: typeof overtime };
+  return replaceReactiveMembers(query,{ get overtime() { return overtime; } });
 }
 
-export interface UseTaskSubscriptionOptions<TTask extends TaskRecord = TaskRecord> {
+export interface UseTaskSubscriptionOptions {
   taskId: string;
-  taskProvider?: TaskProvider<TTask>;
+  taskProvider?: TaskProvider;
   enabled?: boolean;
-  onTask: (task: TTask) => void;
+  onTask: (task: TaskRecord) => void;
+  onError?: (error: TaskError) => void;
 }
 
-export function useTaskSubscription<TTask extends TaskRecord = TaskRecord>(
-  options: UseTaskSubscriptionOptions<TTask>,
+export function useTaskSubscription(
+  options: UseTaskSubscriptionOptions,
 ): void {
-  const adminContext = captureAdminContext();
+  const adminContext=captureAdminContext();
   $effect(() => {
-    const enabled = options.enabled ?? true;
-    if (!enabled) return;
+    const enabled=options.enabled??true;
+    if(!enabled) return;
 
-    const provider = normalizeTaskProvider<TTask>(options.taskProvider, adminContext);
-    if (!provider.subscribe) {
+    const provider=normalizeTaskProvider(options.taskProvider,adminContext);
+    if(!provider.subscribe) {
       throw new Error('TaskProvider does not implement subscribe');
     }
 
-    const subscription = provider.subscribe(options.taskId, options.onTask);
-    if (!subscription) return;
+    const subscription=provider.subscribe(options.taskId,options.onTask,options.onError);
 
-    if (typeof subscription === 'function') {
+    if(typeof subscription==='function') {
       return subscription;
     }
 
-    if (typeof subscription.unsubscribe === 'function') {
+    if(typeof subscription.unsubscribe==='function') {
       return () => subscription.unsubscribe();
     }
   });

package/src/task-provider.ts

@@ -0,0 +1,115 @@
+import { Type } from '@sinclair/typebox';
+import { checkExact } from './schema-validation';
+import { snapshotPlainData } from './plain-data';
+import { TaskError, decodeTaskList, decodeTaskRecord, decodeTaskSubmitOptions, type SubmitTaskOptions } from './task-contract';
+import { requiredTaskClientMethod, taskClientMethod, taskHandleField, taskHandleMethod, validatedTaskSubscription } from './task-subscription';
+import type { TaskHandle, TaskProvider } from './types';
+
+export interface TaskTransport {
+  submit(name: string, options?: SubmitTaskOptions): Promise<unknown>;
+  get(id: string): Promise<unknown>;
+  list?(params?: Record<string, unknown>): Promise<unknown>;
+  listDlq?(params?: Record<string, unknown>): Promise<unknown>;
+  cancel?(id: string): Promise<unknown>;
+  retry?(id: string): Promise<unknown>;
+  subscribe?(id: string, callback: (task: unknown) => void, onError?: (error: unknown) => void): unknown;
+}
+
+const providers = new WeakMap<TaskTransport, TaskProvider>();
+const paramsSchema = Type.Record(Type.String(), Type.Unknown());
+
+export function taskInputText(value: unknown): string {
+  if (typeof value === 'string' && value.trim().length > 0) return value;
+  throw new TaskError('INVALID_TASK_INPUT');
+}
+
+export function taskQueryParams(value: unknown): Record<string, unknown> {
+  try {
+    const candidate = snapshotPlainData(value);
+    if (checkExact(paramsSchema, candidate)) return candidate;
+  } catch {
+    // Query inputs must be detached plain data.
+  }
+  throw new TaskError('INVALID_TASK_INPUT');
+}
+
+async function request(invoke: () => unknown, write = false): Promise<unknown> {
+  try { return await invoke(); }
+  catch { throw new TaskError('TASK_PROVIDER_FAILED', write); }
+}
+
+function handle(value: unknown): TaskHandle {
+  const rawId = taskHandleField(value, 'id', true);
+  if (typeof rawId !== 'string' || !rawId.trim()) throw new TaskError('INVALID_TASK_RESPONSE', true);
+  const id = rawId;
+  const wait = taskHandleMethod(value, 'wait', true);
+  const result: TaskHandle = {
+    id,
+    async wait() { return decodeTaskRecord(await request(() => wait()), id); },
+  };
+  if (taskHandleField(value, 'cancel', true) !== undefined) {
+    const cancel = taskHandleMethod(value, 'cancel', true);
+    result.cancel = async () => decodeTaskRecord(await request(() => cancel(), true), id, true);
+  }
+  if (taskHandleField(value, 'retry', true) !== undefined) {
+    const retry = taskHandleMethod(value, 'retry', true);
+    result.retry = async () => decodeTaskRecord(await request(() => retry(), true), id, true);
+  }
+  if (taskHandleField(value, 'subscribe', true) !== undefined) {
+    const subscribe = taskHandleMethod(value, 'subscribe', true);
+    result.subscribe = (callback, onError) => validatedTaskSubscription(
+      (onUpdate, onFailure) => subscribe(onUpdate, onFailure),
+      value => decodeTaskRecord(value, id), callback, onError,
+    );
+  }
+  return result;
+}
+
+export function withValidatedTaskProvider(transport: TaskTransport): TaskProvider {
+  const existing = providers.get(transport);
+  if (existing) return existing;
+  const submit = requiredTaskClientMethod(transport, 'submit');
+  const get = requiredTaskClientMethod(transport, 'get');
+  const list = taskClientMethod(transport, 'list', true);
+  const listDlq = taskClientMethod(transport, 'listDlq', true);
+  const cancel = taskClientMethod(transport, 'cancel', true);
+  const retry = taskClientMethod(transport, 'retry', true);
+  const subscribe = taskClientMethod(transport, 'subscribe', true);
+  const provider: TaskProvider = {
+    async submit(name, options) {
+      const taskName = taskInputText(name);
+      const input = options === undefined ? undefined : decodeTaskSubmitOptions(options);
+      return handle(await request(() => submit(taskName, input), true));
+    },
+    async get(taskId) {
+      const id = taskInputText(taskId);
+      return decodeTaskRecord(await request(() => get(id)), id);
+    },
+  };
+  if (list) provider.list = async params => {
+    const input = params === undefined ? undefined : taskQueryParams(params);
+    return decodeTaskList(await request(() => list(input)));
+  };
+  if (listDlq) provider.listDlq = async params => {
+    const input = params === undefined ? undefined : taskQueryParams(params);
+    return decodeTaskList(await request(() => listDlq(input)));
+  };
+  if (cancel) provider.cancel = async taskId => {
+    const id = taskInputText(taskId);
+    return decodeTaskRecord(await request(() => cancel(id), true), id, true);
+  };
+  if (retry) provider.retry = async taskId => {
+    const id = taskInputText(taskId);
+    return decodeTaskRecord(await request(() => retry(id), true), id, true);
+  };
+  if (subscribe) provider.subscribe = (taskId, callback, onError) => {
+    const id = taskInputText(taskId);
+    return validatedTaskSubscription(
+      (onUpdate, onFailure) => subscribe(id, onUpdate, onFailure),
+      value => decodeTaskRecord(value, id), callback, onError,
+    );
+  };
+  providers.set(transport, provider);
+  providers.set(provider, provider);
+  return provider;
+}