@ct-agents/worker 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ct-agents/worker",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "files": [
     "src"
@@ -12,10 +12,11 @@
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@ct-agents/prompts": "0.1.7",
-    "@ct-agents/protocol": "0.1.7",
-    "@ct-agents/memory": "0.1.7",
-    "@ct-agents/tools": "0.1.7"
+    "@ct-agents/harness": "0.1.9",
+    "@ct-agents/memory": "0.1.9",
+    "@ct-agents/prompts": "0.1.9",
+    "@ct-agents/protocol": "0.1.9",
+    "@ct-agents/tools": "0.1.9"
   },
   "optionalDependencies": {
     "dockerode": "4.0.9"

package/src/index.ts

@@ -951,7 +951,7 @@ function buildSyntheticSession(item: ToolWorkItem, harnessId: string, harnessVer
     environmentId: item.environmentId as EnvironmentId,
     environmentUpdatedAt: now,
     title: item.sessionId,
-    metadata: {},
+    metadata: item.sessionMetadata ?? {},
     createdAt: now,
     updatedAt: now,
   };
@@ -1022,6 +1022,10 @@ function parseToolWorkItem(value: unknown): ToolWorkItem {
     item.resume = parseToolResumeWorkPayload(record.resume);
   }
 
+  if (record.sessionMetadata !== undefined) {
+    item.sessionMetadata = expectRecord(record.sessionMetadata, 'sessionMetadata 必须是对象');
+  }
+
   if (isRecord(record.resourceBindings)) {
     item.resourceBindings = record.resourceBindings;
   }

package/src/resources/index.ts

@@ -1,3 +1,4 @@
 export * from './database/index.js';
 export * from './platform-proxy.js';
+export * from './text-generation/index.js';
 export * from './web-search/index.js';

package/src/resources/text-generation/index.ts

@@ -0,0 +1,371 @@
+import type {
+  HarnessModelRunInput,
+  ResourceDefinition,
+  TextGenerationErrorCode,
+  TextGenerationInput,
+  TextGenerationProvider,
+  TextGenerationResource,
+  TextGenerationResult,
+} from '@ct-agents/protocol';
+import { runAnthropic } from '@ct-agents/harness/llm/anthropic-provider.js';
+import type {
+  NormalizedModelOutput,
+  ResolvedProviderConfig,
+} from '@ct-agents/harness/llm/model-port.js';
+import { runOpenAI } from '@ct-agents/harness/llm/openai-provider.js';
+import { z } from 'zod';
+import type { EnvironmentWorkerResourceImplementation } from '../../index.js';
+
+const DEFAULT_MAX_OUTPUT_TOKENS = 4_096;
+const DEFAULT_TIMEOUT_MS = 60_000;
+const MAX_PROMPT_BYTES = 512 * 1_024;
+const MAX_SYSTEM_PROMPT_BYTES = 32 * 1_024;
+const MAX_RESPONSE_BYTES = 1_024 * 1_024;
+
+export type TextGenerationOptions = {
+  provider: TextGenerationProvider;
+  apiKey: string;
+  defaultModel: string;
+  baseURL?: string;
+  maxOutputTokens: number;
+  timeoutMs: number;
+};
+
+const providerBaseUrlSchema = z.string().trim().max(2_048).url().refine((value) => {
+  const url = new URL(value);
+  return (url.protocol === 'https:' || url.protocol === 'http:')
+    && !url.username
+    && !url.password;
+}, 'baseURL 必须是无用户凭证的 HTTP(S) URL');
+
+export const textGenerationOptionsSchema = z.object({
+  provider: z.enum(['openai', 'anthropic']),
+  apiKey: z.string().trim().min(1).meta({ secret: true }),
+  defaultModel: z.string().trim().min(1).max(256),
+  baseURL: providerBaseUrlSchema.optional(),
+  maxOutputTokens: z.number().int().min(128).max(16_384).default(DEFAULT_MAX_OUTPUT_TOKENS),
+  timeoutMs: z.number().int().min(1_000).max(120_000).default(DEFAULT_TIMEOUT_MS),
+}).strict();
+
+const textGenerationInputSchema = z.object({
+  prompt: z.string().min(1),
+  systemPrompt: z.string().optional(),
+  model: z.string().trim().min(1).max(256).optional(),
+  maxOutputTokens: z.number().int().min(128).max(16_384).optional(),
+}).strict();
+
+export type TextGenerationProviderRunInput = {
+  provider: TextGenerationProvider;
+  config: ResolvedProviderConfig;
+  input: HarnessModelRunInput;
+};
+
+export type TextGenerationResourceDependencies = {
+  runProvider?: (input: TextGenerationProviderRunInput) => Promise<NormalizedModelOutput>;
+  now?: () => number;
+  defaultAbortSignal?: AbortSignal;
+};
+
+function byteLength(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function durationSince(startedAt: number, now: () => number): number {
+  return Math.max(0, Math.round(now() - startedAt));
+}
+
+function failure(input: {
+  provider: TextGenerationProvider;
+  model: string;
+  startedAt: number;
+  now: () => number;
+  code: TextGenerationErrorCode;
+  message: string;
+  retryable: boolean;
+}): TextGenerationResult {
+  return {
+    success: false,
+    provider: input.provider,
+    model: input.model,
+    durationMs: durationSince(input.startedAt, input.now),
+    error: {
+      code: input.code,
+      message: input.message,
+      retryable: input.retryable,
+    },
+  };
+}
+
+function readHttpStatus(error: unknown): number | undefined {
+  const visited = new Set<unknown>();
+  let current: unknown = error;
+  while (current && typeof current === 'object' && !visited.has(current)) {
+    visited.add(current);
+    const status = 'status' in current ? (current as { status?: unknown }).status : undefined;
+    if (typeof status === 'number' && Number.isFinite(status)) {
+      return status;
+    }
+    current = 'cause' in current ? (current as { cause?: unknown }).cause : undefined;
+  }
+  return undefined;
+}
+
+function classifyProviderError(error: unknown): {
+  code: TextGenerationErrorCode;
+  message: string;
+  retryable: boolean;
+} {
+  const status = readHttpStatus(error);
+  if (status === 400 || status === 404 || status === 422) {
+    return {
+      code: 'TEXT_GENERATION_INVALID_REQUEST',
+      message: '模型服务拒绝了生成请求，请检查 Environment 模型配置',
+      retryable: false,
+    };
+  }
+  if (status === 401 || status === 403) {
+    return {
+      code: 'TEXT_GENERATION_AUTH_FAILED',
+      message: '模型服务认证失败，请检查 Environment 密钥',
+      retryable: false,
+    };
+  }
+  if (status === 429) {
+    return {
+      code: 'TEXT_GENERATION_RATE_LIMITED',
+      message: '模型服务请求过于频繁，请稍后重试',
+      retryable: true,
+    };
+  }
+  if (status !== undefined && status >= 500) {
+    return {
+      code: 'TEXT_GENERATION_PROVIDER_UNAVAILABLE',
+      message: '模型服务暂时不可用，请稍后重试',
+      retryable: true,
+    };
+  }
+  return {
+    code: 'TEXT_GENERATION_PROVIDER_ERROR',
+    message: '模型服务返回了非预期错误',
+    retryable: status === undefined,
+  };
+}
+
+function abortError(reason?: unknown): Error {
+  if (reason instanceof Error && reason.name === 'AbortError') {
+    return reason;
+  }
+  return new DOMException('aborted', 'AbortError');
+}
+
+async function defaultRunProvider(
+  input: TextGenerationProviderRunInput,
+): Promise<NormalizedModelOutput> {
+  return input.provider === 'openai'
+    ? runOpenAI(input.input, input.config)
+    : runAnthropic(input.input, input.config);
+}
+
+function buildModelInput(input: TextGenerationInput, abortSignal: AbortSignal): HarnessModelRunInput {
+  const systemPrompt = input.systemPrompt?.trim() ?? '';
+  return {
+    context: {
+      messages: [
+        ...(systemPrompt
+          ? [{
+              role: 'system' as const,
+              content: [{ type: 'text' as const, text: systemPrompt }],
+            }]
+          : []),
+        {
+          role: 'user',
+          content: [{ type: 'text', text: input.prompt }],
+        },
+      ],
+    },
+    systemPrompt,
+    tools: [],
+    abortSignal,
+  };
+}
+
+/**
+ * 创建不进入 Harness Agent loop 的单轮文本生成 Resource。
+ *
+ * Environment 冻结 provider、凭证、baseURL 和最大预算；调用方只能在该边界内选择模型和更小预算。
+ */
+export function createTextGenerationResource(
+  rawOptions: TextGenerationOptions,
+  dependencies: TextGenerationResourceDependencies = {},
+): TextGenerationResource {
+  const options = textGenerationOptionsSchema.parse(rawOptions);
+  const runProvider = dependencies.runProvider ?? defaultRunProvider;
+  const now = dependencies.now ?? Date.now;
+
+  return {
+    async generate(rawInput, context) {
+      const startedAt = now();
+      const candidateModel = typeof rawInput?.model === 'string' && rawInput.model.trim()
+        ? rawInput.model.trim()
+        : options.defaultModel;
+      const parsedInput = textGenerationInputSchema.safeParse(rawInput);
+      if (!parsedInput.success) {
+        return failure({
+          provider: options.provider,
+          model: candidateModel,
+          startedAt,
+          now,
+          code: 'TEXT_GENERATION_INVALID_REQUEST',
+          message: '文本生成请求不合法',
+          retryable: false,
+        });
+      }
+      const input = parsedInput.data;
+      const model = input.model ?? options.defaultModel;
+      if (
+        byteLength(input.prompt) > MAX_PROMPT_BYTES
+        || byteLength(input.systemPrompt ?? '') > MAX_SYSTEM_PROMPT_BYTES
+      ) {
+        return failure({
+          provider: options.provider,
+          model,
+          startedAt,
+          now,
+          code: 'TEXT_GENERATION_INVALID_REQUEST',
+          message: '文本生成输入超过 Resource 安全上限',
+          retryable: false,
+        });
+      }
+      const maxOutputTokens = input.maxOutputTokens ?? options.maxOutputTokens;
+      if (maxOutputTokens > options.maxOutputTokens) {
+        return failure({
+          provider: options.provider,
+          model,
+          startedAt,
+          now,
+          code: 'TEXT_GENERATION_INVALID_REQUEST',
+          message: '调用级输出预算不能超过 Environment 上限',
+          retryable: false,
+        });
+      }
+
+      const upstreamSignal = context?.abortSignal ?? dependencies.defaultAbortSignal;
+      if (upstreamSignal?.aborted) {
+        throw abortError(upstreamSignal.reason);
+      }
+      const controller = new AbortController();
+      let timedOut = false;
+      const onUpstreamAbort = () => controller.abort(upstreamSignal?.reason);
+      upstreamSignal?.addEventListener('abort', onUpstreamAbort, { once: true });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, options.timeoutMs);
+
+      try {
+        const output = await runProvider({
+          provider: options.provider,
+          config: {
+            model,
+            apiKey: options.apiKey,
+            ...(options.baseURL ? { baseURL: options.baseURL } : {}),
+            maxOutputTokens,
+          },
+          input: buildModelInput(input, controller.signal),
+        });
+        const text = output.text.trim();
+        if (!text) {
+          return failure({
+            provider: options.provider,
+            model,
+            startedAt,
+            now,
+            code: 'TEXT_GENERATION_EMPTY_RESPONSE',
+            message: '模型服务返回了空文本',
+            retryable: false,
+          });
+        }
+        if (output.toolCalls.length > 0 || byteLength(text) > MAX_RESPONSE_BYTES) {
+          return failure({
+            provider: options.provider,
+            model,
+            startedAt,
+            now,
+            code: 'TEXT_GENERATION_PROVIDER_ERROR',
+            message: '模型服务返回了不符合单轮文本契约的结果',
+            retryable: false,
+          });
+        }
+        return {
+          success: true,
+          provider: options.provider,
+          model,
+          text,
+          durationMs: durationSince(startedAt, now),
+        };
+      } catch (error) {
+        if (upstreamSignal?.aborted) {
+          throw abortError(upstreamSignal.reason ?? error);
+        }
+        if (timedOut) {
+          return failure({
+            provider: options.provider,
+            model,
+            startedAt,
+            now,
+            code: 'TEXT_GENERATION_TIMEOUT',
+            message: '文本生成超时，请稍后重试',
+            retryable: true,
+          });
+        }
+        const classified = classifyProviderError(error);
+        return failure({
+          provider: options.provider,
+          model,
+          startedAt,
+          now,
+          ...classified,
+        });
+      } finally {
+        clearTimeout(timer);
+        upstreamSignal?.removeEventListener('abort', onUpstreamAbort);
+      }
+    },
+  };
+}
+
+export function createTextGenerationResourceImplementation(
+  dependencies: TextGenerationResourceDependencies = {},
+): EnvironmentWorkerResourceImplementation<TextGenerationResource, TextGenerationOptions> {
+  return {
+    title: '模型文本生成',
+    description: '使用 Environment 配置的模型服务执行单轮、无 Tool 的文本生成。',
+    options: textGenerationOptionsSchema,
+    factory: (options, context) => createTextGenerationResource(options, {
+      ...dependencies,
+      defaultAbortSignal: context.abortSignal ?? dependencies.defaultAbortSignal,
+    }),
+  };
+}
+
+export function createTextGenerationResourceDefinition(
+  dependencies: TextGenerationResourceDependencies = {},
+): ResourceDefinition<TextGenerationResource, TextGenerationOptions> {
+  return {
+    id: 'textGeneration',
+    title: '模型文本生成',
+    description: '供应商无关的单轮文本生成 Resource。',
+    implementations: [{
+      id: 'provider-api',
+      title: '模型 Provider API',
+      description: '通过 OpenAI 或 Anthropic 兼容 API 生成文本。',
+      supportedExecutionModes: ['hosted', 'self_hosted'],
+      optionsSchema: textGenerationOptionsSchema,
+      optionsJsonSchema: z.toJSONSchema(textGenerationOptionsSchema),
+      factory: (options) => createTextGenerationResource(
+        textGenerationOptionsSchema.parse(options),
+        dependencies,
+      ),
+    }],
+  };
+}