@ct-agents/worker 0.4.1 → 0.5.0

package/package.json

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

package/src/index.ts

@@ -34,7 +34,7 @@ import {
   createWebSearchToolHandler,
 } from '@ct-agents/tools/builtin-tools';
 import { z } from 'zod';
-import { createPlatformResourceProxy } from './resources/platform-proxy.js';
+import { createPlatformResourceProxy, createPlatformTextGenerationProxy } from './resources/platform-proxy.js';
 import { WorkerHttpTransport } from './worker-http-transport.js';
 import { runLeasedItem } from './leased-item-runner.js';
 
@@ -86,6 +86,8 @@ export type WorkerSandboxManager = {
 };
 
 export type EnvironmentWorkerInput = {
+  /** 当前注册实例身份，仅用于绑定平台代理的 lease audit。 */
+  workerInstanceId?: string;
   workQueue: WorkerWorkQueue;
   toolRegistry: ToolRegistry;
   resources?: ResourceSlots;
@@ -125,6 +127,7 @@ export const DEFAULT_CLAIM_BLOCK_MS = 15_000;
 const PLATFORM_PROXY_RESOURCE_CAPABILITIES = [
   { slot: 'skills', implementationId: 'platform-skills-store' },
   { slot: 'memory', implementationId: 'platform-memory-store' },
+  { slot: 'textGeneration', implementationId: 'platform-model' },
 ] as const;
 const PLATFORM_PROXY_RESOURCE_SLOTS = new Set<string>(
   PLATFORM_PROXY_RESOURCE_CAPABILITIES.map((capability) => capability.slot),
@@ -171,7 +174,8 @@ export function createWorkerCapabilityRegistration(input: {
     };
   });
   const resourceCapabilities = Object.entries(input.resourceImpls).flatMap(([slot, implementations]) => (
-    Object.keys(implementations).map((implementationId) => ({ slot, implementationId }))
+    Object.keys(implementations).filter((implementationId) => !(slot === 'textGeneration' && implementationId === 'platform-model'))
+      .map((implementationId) => ({ slot, implementationId }))
   ));
   if (input.platformResourceProxy) {
     for (const capability of PLATFORM_PROXY_RESOURCE_CAPABILITIES) {
@@ -388,6 +392,18 @@ export class EnvironmentWorker {
     const resources: ResourceSlots = {};
     for (const [slotName, bindingValue] of Object.entries(item.resourceBindings)) {
       const binding = parseResourceBinding(slotName, bindingValue);
+      if (slotName === 'textGeneration' && binding.implementationId === 'platform-model') {
+        const proxy = this.input.platformResourceProxy;
+        if (!proxy || !item.leaseId || !this.input.workerInstanceId?.trim()) throw new Error('平台文本生成缺少代理配置或当前 lease/Worker 身份');
+        const timeoutMs = binding.options.timeoutMs;
+        if (typeof timeoutMs !== 'number' || !Number.isInteger(timeoutMs) || timeoutMs < 1000 || timeoutMs > 120000) throw new Error('平台文本生成 binding timeoutMs 无效');
+        const signals = [proxy.signal, this.input.abortSignal].filter((signal): signal is AbortSignal => Boolean(signal));
+        resources[slotName] = createPlatformTextGenerationProxy({ ...proxy, environmentId: item.environmentId, timeoutMs,
+          signal: signals.length ? AbortSignal.any(signals) : undefined,
+          audit: { workId: item.workId, sessionId: item.sessionId, toolCallEventId: item.toolCallEventId,
+            leaseId: item.leaseId, workerInstanceId: this.input.workerInstanceId } });
+        continue;
+      }
       const implementations = this.input.resourceImpls?.[slotName];
       const implementation = implementations?.[binding.implementationId];
       if (!implementation) {

package/src/resources/platform-proxy.ts

@@ -1,4 +1,19 @@
 import { platformApiPath } from '../platform-api-path.js';
+import { MODEL_TIERS, type TextGenerationResource } from '@ct-agents/protocol';
+import { z } from 'zod';
+
+const textGenerationResultBase = z.object({
+  modelTier: z.enum(MODEL_TIERS), provider: z.enum(['openai', 'anthropic']),
+  model: z.string().min(1), durationMs: z.number().nonnegative(),
+});
+const textGenerationResultSchema = z.discriminatedUnion('success', [
+  textGenerationResultBase.extend({ success: z.literal(true), text: z.string() }),
+  textGenerationResultBase.extend({ success: z.literal(false), error: z.object({
+    code: z.enum(['TEXT_GENERATION_INVALID_REQUEST', 'TEXT_GENERATION_AUTH_FAILED', 'TEXT_GENERATION_RATE_LIMITED',
+      'TEXT_GENERATION_TIMEOUT', 'TEXT_GENERATION_EMPTY_RESPONSE', 'TEXT_GENERATION_PROVIDER_UNAVAILABLE', 'TEXT_GENERATION_PROVIDER_ERROR']),
+    message: z.string(), retryable: z.boolean(),
+  }) }),
+]);
 
 export type PlatformResourceProxyInput = {
   baseUrl: string;
@@ -70,6 +85,8 @@ async function parseProxyEnvelope(response: Response): Promise<unknown> {
  * worker 只持有 environment key，不持有平台内置 resource 的原始密钥。
  */
 export async function invokePlatformResourceProxy(input: InvokePlatformResourceProxyInput): Promise<unknown> {
+  const textGeneration = input.slot === 'textGeneration' && input.implementationId === 'platform-model' && input.method === 'generate';
+  if (textGeneration && input.signal?.aborted) throw new DOMException('请求已取消', 'AbortError');
   const baseUrl = trimTrailingSlash(input.baseUrl);
   const fetchImpl = input.fetchImpl ?? fetch;
   const headers = new Headers();
@@ -99,6 +116,7 @@ export async function invokePlatformResourceProxy(input: InvokePlatformResourceP
     });
     return await parseProxyEnvelope(response);
   } catch (error) {
+    if (textGeneration && input.signal?.aborted) throw new DOMException('请求已取消', 'AbortError');
     if (isAbortError(error)) {
       throw new Error('平台 resource proxy 请求超时', { cause: error });
     }
@@ -109,6 +127,27 @@ export async function invokePlatformResourceProxy(input: InvokePlatformResourceP
   }
 }
 
+/** 文本生成的 AbortSignal 留在本地传输层，身份来自领取上下文，不进入业务参数。 */
+export function createPlatformTextGenerationProxy(input: Omit<PlatformResourceProxyInput, 'slot' | 'implementationId' | 'audit' | 'timeoutMs'> & {
+  timeoutMs: number;
+  audit: PlatformResourceProxyInput['audit'] & { leaseId: string; workerInstanceId: string };
+}): TextGenerationResource {
+  return {
+    async generate(request, context) {
+      const signals = [input.signal, context?.abortSignal].filter((signal): signal is AbortSignal => Boolean(signal));
+      const signal = signals.length ? AbortSignal.any(signals) : undefined;
+      const result = await invokePlatformResourceProxy({ ...input, slot: 'textGeneration', implementationId: 'platform-model',
+        method: 'generate', args: [request], timeoutMs: input.timeoutMs + 5000,
+        requestTimeoutMs: Math.min(input.requestTimeoutMs ?? Infinity, input.timeoutMs + 10000), signal });
+      const parsed = textGenerationResultSchema.safeParse(result);
+      if (!parsed.success) {
+        throw new Error('平台文本生成响应不符合协议');
+      }
+      return parsed.data;
+    },
+  };
+}
+
 /**
  * 创建一个通过平台 Resource proxy 访问的动态 resource。
  *

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

@@ -1,402 +1,7 @@
-import type {
-  HarnessModelRunInput,
-  ResourceDefinition,
-  TextGenerationErrorCode,
-  TextGenerationInput,
-  TextGenerationProvider,
-  TextGenerationResource,
-  TextGenerationResult,
-} from '@ct-agents/protocol';
-import { ModelOutputError, ModelProviderError } from '@ct-agents/harness';
-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 DEFAULT_PROVIDER = 'anthropic' as const;
-const DEFAULT_MODEL = 'deepseek-v4-flash';
-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;
-} {
-  if (error instanceof ModelOutputError) {
-    const isCompletedEmpty = error.diagnostic.stage === 'response_completion'
-      && [
-        'completed_empty',
-        'end_turn',
-        'stop_sequence',
-        'tool_use',
-        'refusal',
-        'missing',
-      ].includes(error.diagnostic.completionReason);
-    return isCompletedEmpty
-      ? {
-          code: 'TEXT_GENERATION_EMPTY_RESPONSE',
-          message: '模型服务返回了空文本',
-          retryable: false,
-        }
-      : {
-          code: 'TEXT_GENERATION_PROVIDER_ERROR',
-          message: '模型服务返回了非预期错误',
-          retryable: true,
-        };
-  }
-  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 && !(error instanceof ModelProviderError),
-  };
-}
-
-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> {
-  return {
-    id: 'textGeneration',
-    title: '模型文本生成',
-    description: '供应商无关的单轮文本生成 Resource。',
-    implementations: [{
-      id: 'provider-api',
-      title: '模型 Provider API',
-      description: '通过 OpenAI 或 Anthropic 兼容 API 生成文本。',
-      supportedExecutionModes: ['hosted', 'self_hosted'],
-      defaultOptions: {
-        provider: DEFAULT_PROVIDER,
-        defaultModel: DEFAULT_MODEL,
-        maxOutputTokens: DEFAULT_MAX_OUTPUT_TOKENS,
-        timeoutMs: DEFAULT_TIMEOUT_MS,
-      },
-      optionsSchema: textGenerationOptionsSchema,
-      optionsJsonSchema: z.toJSONSchema(textGenerationOptionsSchema),
-      factory: (options) => createTextGenerationResource(
-        textGenerationOptionsSchema.parse(options),
-        dependencies,
-      ),
-    }],
-  };
-}
+export {
+  platformModelOptionsSchema as textGenerationOptionsSchema,
+  createPlatformModelResource as createTextGenerationResource,
+  createPlatformModelResourceDefinition as createTextGenerationResourceDefinition,
+} from './platform-model.js';
+export type { TextGenerationProviderRunInput } from './provider-executor.js';
+export type { TextGenerationOptions } from './platform-model.js';

package/src/resources/text-generation/platform-model.ts

@@ -0,0 +1,53 @@
+import { MODEL_TIERS, MODEL_TIER_TITLES, type ResourceDefinition, type TextGenerationResource } from '@ct-agents/protocol';
+import type { ModelTierRegistry } from '@ct-agents/harness';
+import { z } from 'zod';
+import { createProviderTextGenerationResource, type TextGenerationResourceDependencies } from './provider-executor.js';
+
+export const platformModelOptionsSchema = z.object({
+  defaultModel: z.enum(MODEL_TIERS).default('balanced').meta({ title: '默认档位' }),
+  maxOutputTokens: z.number().int().min(128).max(16384).default(4096).meta({ title: '输出上限' }),
+  timeoutMs: z.number().int().min(1000).max(120000).default(60000).meta({ title: '超时（毫秒）' }),
+}).strict();
+
+export type TextGenerationOptions = z.output<typeof platformModelOptionsSchema>;
+
+const inputSchema = z.object({
+  prompt: z.string().min(1), systemPrompt: z.string().optional(),
+  model: z.enum(MODEL_TIERS).optional(), maxOutputTokens: z.number().int().min(128).max(16384).optional(),
+}).strict();
+
+/** 平台工厂持有部署快照，公开请求只能选择档位和收紧预算。 */
+export function createPlatformModelResource(
+  rawOptions: z.input<typeof platformModelOptionsSchema>,
+  dependencies: TextGenerationResourceDependencies & { modelRegistry: ModelTierRegistry },
+): TextGenerationResource {
+  const options = platformModelOptionsSchema.parse(rawOptions);
+  return {
+    async generate(rawInput, context) {
+      const parsed = inputSchema.safeParse(rawInput);
+      const modelTier = parsed.success ? parsed.data.model ?? options.defaultModel : options.defaultModel;
+      const target = dependencies.modelRegistry.resolve(modelTier);
+      if (!parsed.success) return { success: false, modelTier, provider: target.provider, model: target.model, durationMs: 0,
+        error: { code: 'TEXT_GENERATION_INVALID_REQUEST', message: '文本生成请求不合法', retryable: false } };
+      const resource = createProviderTextGenerationResource({ ...options, provider: target.provider, apiKey: target.apiKey,
+        baseURL: target.baseURL ?? (target.provider === 'openai' ? 'https://api.openai.com/v1' : 'https://api.anthropic.com'), defaultModel: target.model }, dependencies);
+      const result = await resource.generate({ ...parsed.data, model: target.model }, context);
+      return { ...result, modelTier };
+    },
+  };
+}
+
+export function createPlatformModelResourceDefinition(
+  dependencies: TextGenerationResourceDependencies & { modelRegistry: ModelTierRegistry },
+): ResourceDefinition<TextGenerationResource> {
+  const jsonSchema = z.toJSONSchema(platformModelOptionsSchema);
+  const field = jsonSchema.properties?.defaultModel;
+  if (field && typeof field === 'object') {
+    field.oneOf = MODEL_TIERS.map((tier) => ({ const: tier, title: MODEL_TIER_TITLES[tier] }));
+  }
+  return { id: 'textGeneration', title: '模型文本生成', description: '平台部署映射驱动的单轮文本生成。', implementations: [{
+    id: 'platform-model', title: '平台模型服务', supportedExecutionModes: ['hosted', 'self_hosted'],
+    defaultOptions: platformModelOptionsSchema.parse({}), optionsSchema: platformModelOptionsSchema, optionsJsonSchema: jsonSchema,
+    factory: (options) => createPlatformModelResource(platformModelOptionsSchema.parse(options), dependencies),
+  }] };
+}

package/src/resources/text-generation/provider-executor.ts

@@ -0,0 +1,364 @@
+import type {
+  HarnessModelRunInput,
+  TextGenerationErrorCode,
+  TextGenerationInput,
+  TextGenerationProvider,
+  TextGenerationRequestContext,
+  TextGenerationResult,
+} from '@ct-agents/protocol';
+import { ModelOutputError, ModelProviderError } from '@ct-agents/harness';
+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';
+
+
+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;
+}): ProviderTextGenerationResult {
+  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;
+} {
+  if (error instanceof ModelOutputError) {
+    const isCompletedEmpty = error.diagnostic.stage === 'response_completion'
+      && [
+        'completed_empty',
+        'end_turn',
+        'stop_sequence',
+        'tool_use',
+        'refusal',
+        'missing',
+      ].includes(error.diagnostic.completionReason);
+    return isCompletedEmpty
+      ? {
+          code: 'TEXT_GENERATION_EMPTY_RESPONSE',
+          message: '模型服务返回了空文本',
+          retryable: false,
+        }
+      : {
+          code: 'TEXT_GENERATION_PROVIDER_ERROR',
+          message: '模型服务返回了非预期错误',
+          retryable: true,
+        };
+  }
+  const status = readHttpStatus(error);
+  if (status === 400 || status === 404 || status === 422) {
+    return {
+      code: 'TEXT_GENERATION_INVALID_REQUEST',
+      message: '模型服务拒绝了生成请求，请检查平台模型配置',
+      retryable: false,
+    };
+  }
+  if (status === 401 || status === 403) {
+    return {
+      code: 'TEXT_GENERATION_AUTH_FAILED',
+      message: '模型服务认证失败，请检查平台模型凭据',
+      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 && !(error instanceof ModelProviderError),
+  };
+}
+
+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: Pick<TextGenerationInput, 'prompt' | 'systemPrompt'>, 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。
+ *
+ * 内部执行器只接收平台工厂解析的实际目标与预算；公开档位校验由平台工厂承担。
+ */
+export function createProviderTextGenerationResource(
+  rawOptions: TextGenerationOptions,
+  dependencies: TextGenerationResourceDependencies = {},
+): ProviderTextGenerationResource {
+  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);
+      }
+    },
+  };
+}
+
+
+type StripTier<T> = T extends unknown ? Omit<T, 'modelTier'> : never;
+type ProviderTextGenerationResult = StripTier<TextGenerationResult>;
+type ProviderTextGenerationResource = { generate(input: Omit<TextGenerationInput, 'model'> & { model?: string }, context?: TextGenerationRequestContext): Promise<ProviderTextGenerationResult> };