@x-otto/cli 0.0.1-alpha.0

package/dist/bundled-extensions/plugin-otto-wire-protocols/src/openai-responses.ts

@@ -0,0 +1,575 @@
+import { randomUUID } from 'node:crypto'
+
+import { stream, ProviderError } from '@x-otto/shared'
+import { normalizeImageData } from '@x-otto/interchange'
+import {
+  buildRequestHeaders,
+  extractStandardRateLimitHeaders,
+  sanitizeToolRoundtrips,
+  degradedSystemNotificationText,
+  sanitizeSurrogates,
+  toJsonSchema,
+  assembleAssistantMessage,
+  blocksContent,
+  initStreamUsage,
+  toolCallFromParsed,
+  recoverLiteralInvokeToolCalls,
+  registeredToolNames,
+  clampThinkingLevel,
+} from '@x-otto/provider'
+import type {
+  AssistantMessage,
+  Model,
+  ResolvedAuth,
+  StopReason,
+  StreamContext,
+  StreamEvent,
+  StreamOptions,
+  TextContent,
+  ProviderStream,
+  StreamBlock,
+  StreamUsage,
+  TokenDerivedHeader,
+  WireProtocolLogger,
+  WireRequestCustomization,
+  WireRequestCustomizeInput,
+} from '@x-otto/provider'
+
+/** RFC-185 D3：日志走宿主注入端口，缺省 no-op——插件源码禁 createLogger（防第二单例直写 stderr）。 */
+const noopLogger: WireProtocolLogger = { debug: () => {}, info: () => {}, warn: () => {}, error: () => {} }
+
+export type OpenAIResponsesCredentialResolver = () => Promise<string | undefined>
+export type OpenAIResponsesBaseUrlResolver = () => Promise<string | undefined>
+
+// RFC-122 D3：TokenDerivedHeader 定义单一真源在 @x-otto/provider（协议中立层，见该包
+// types.ts 头注释）——此前本文件与 openai-completions.ts 各自重复定义一份相同形状，
+// 终局 review 收敛为直接 import，避免两份定义静默漂移。
+
+export function toReasoningEffort(level: string): 'low' | 'medium' | 'high' {
+  // RFC-235：OpenAI Responses reasoning.effort 官方支持 minimal/low/medium/high（**无 max**）。
+  // otto 词表去掉了 minimal（对齐 Claude Code），故本翻译表映射到 low/medium/high；xhigh/max
+  // 降级为 high（OpenAI 无更高档）。降级已在调用处用 clampThinkingLevel 完成。
+  switch (level) {
+    case 'low':
+      return 'low'
+    case 'medium':
+      return 'medium'
+    case 'high':
+    case 'xhigh':
+    case 'max':
+      return 'high'
+    default:
+      return 'medium'
+  }
+}
+
+/**
+ * 将内部消息转换为 OpenAI Responses `input` 数组。
+ *
+ * - user/assistant 文本走 `input_text`/`output_text` content part；
+ * - 工具调用 → `function_call`（call_id + arguments 字符串）；
+ * - 工具结果 → `function_call_output`（call_id + output 字符串）。
+ */
+// RFC-144 M2：OpenAI Responses 的 `input` 数组 role 限定 `'developer'|'user'|'assistant'`
+// （无 'system'，系统指令走顶层 `instructions` 字段，见 buildResponsesBody），结构上不存在
+// "消息数组中间插入系统级消息"的原生机制，走决策 1 已述的降级路径：`role:'user'` + 显式前缀
+// （`degradedSystemNotificationText`，见 sanitize-tool-roundtrips.ts 单一真源）。
+
+export function buildResponsesInput(context: StreamContext): unknown[] {
+  const input: unknown[] = []
+
+  for (const msg of sanitizeToolRoundtrips(context.messages)) {
+    if (msg.role === 'user') {
+      if (typeof msg.content === 'string') {
+        input.push({
+          role: 'user',
+          content: [{ type: 'input_text', text: sanitizeSurrogates(msg.content) }],
+        })
+      } else {
+        input.push({
+          role: 'user',
+          content: msg.content.map((part) => {
+            if (part.type === 'text') {
+              return { type: 'input_text', text: sanitizeSurrogates(part.text) }
+            }
+            if (part.type === 'image') {
+              const { base64, mediaType, valid } = normalizeImageData(part.source, part.mime)
+              if (!valid) {
+                return { type: 'input_text', text: '[image omitted: corrupted or empty data]' }
+              }
+              return {
+                type: 'input_image',
+                image_url: `data:${mediaType || 'image/png'};base64,${base64}`,
+              }
+            }
+            return { type: 'input_text', text: '[unsupported]' }
+          }),
+        })
+      }
+    } else if (msg.role === 'assistant') {
+      const textParts = msg.content
+        .filter((c): c is TextContent => c.type === 'text')
+        .filter((c) => c.text.trim().length > 0)
+        .map((c) => sanitizeSurrogates(c.text))
+        .join('')
+
+      if (textParts) {
+        input.push({
+          role: 'assistant',
+          content: [{ type: 'output_text', text: textParts }],
+        })
+      }
+
+      for (const c of msg.content) {
+        if (c.type === 'tool_call') {
+          input.push({
+            type: 'function_call',
+            call_id: c.id,
+            name: c.name,
+            arguments: JSON.stringify(c.arguments),
+          })
+        }
+      }
+    } else if (msg.role === 'tool_result') {
+      input.push({
+        type: 'function_call_output',
+        call_id: msg.toolCallId,
+        output: sanitizeSurrogates(
+          msg.content.map((c) => (c.type === 'text' ? c.text : '')).join(''),
+        ),
+      })
+    } else if (msg.role === 'system_notification') {
+      input.push({
+        role: 'user',
+        content: [
+          { type: 'input_text', text: sanitizeSurrogates(degradedSystemNotificationText(msg.content)) },
+        ],
+      })
+    }
+  }
+
+  return input
+}
+
+export function buildResponsesBody(model: Model, context: StreamContext): Record<string, unknown> {
+  const modelName = model.name
+
+  const body: Record<string, unknown> = {
+    model: modelName,
+    input: buildResponsesInput(context),
+    stream: true,
+  }
+
+  // RFC-213：请求体策略完全由 manifest 声明式驱动（Model.responseBodyPolicy），
+  // 零厂商字符串判断——此前的 `model.api === 'openai-codex-responses'` 分支自 RFC-122
+  // provider 插件化迁移后已物理不可达（Codex 插件的 preserveProviderId:true 令
+  // model.api 实际值为裸 id "openai-codex"，见 RFC-213 背景的逐层源码追溯），是死代码，
+  // 且官方 openai/codex CLI 源码从不发送 max_output_tokens（reasoning 模型系列经
+  // Responses API 收到该字段有被 400 拒绝的已知风险）。
+  const policy = model.responseBodyPolicy
+  if (policy?.store !== undefined) {
+    body.store = policy.store
+  }
+  if (policy?.sendMaxOutputTokens !== false) {
+    body.max_output_tokens = context.maxTokens ?? model.maxOutputTokens
+  }
+
+  if (context.systemPrompt) {
+    body.instructions = sanitizeSurrogates(context.systemPrompt)
+  }
+
+  if (context.temperature !== undefined && !model.reasoning) {
+    body.temperature = context.temperature
+  }
+  if (model.reasoning && context.thinkingLevel) {
+    body.reasoning = { effort: toReasoningEffort(clampThinkingLevel(context.thinkingLevel, model.thinkingLevels)) }
+  }
+
+  if (context.tools && context.tools.length > 0) {
+    body.tools = context.tools.map((tool) => ({
+      type: 'function',
+      name: tool.name,
+      description: tool.description,
+      parameters: toJsonSchema(tool.parameters),
+    }))
+  }
+
+  return body
+}
+
+interface ResponsesStreamState extends StreamUsage {
+  model: Model
+  blocks: Map<number, StreamBlock>
+  stopReason: StopReason
+}
+
+function ensureBlock(
+  blocks: Map<number, StreamBlock>,
+  index: number,
+  kind: 'text' | 'thinking',
+): StreamBlock {
+  let block = blocks.get(index)
+  if (!block) {
+    block = kind === 'text' ? { kind: 'text', text: '' } : { kind: 'thinking', text: '' }
+    blocks.set(index, block)
+  }
+  return block
+}
+
+function initStreamState(model: Model): ResponsesStreamState {
+  return {
+    ...initStreamUsage(),
+    model,
+    blocks: new Map(),
+    stopReason: 'end_turn',
+  }
+}
+
+function buildAssistantMessage(state: ResponsesStreamState, final = false): AssistantMessage {
+  return assembleAssistantMessage(
+    { api: state.model.api, provider: state.model.provider, model: state.model.id },
+    blocksContent(state.blocks, final),
+    state,
+    state.stopReason,
+  )
+}
+
+/**
+ * 单次 SSE 事件分发。解析 type + data 并更新 state，返回本事件应输出的 StreamEvent 数组。
+ * 不存在 type 匹配时返回空数组。
+ *
+ * `response.failed` / `error` 事件设置 fatal=true，调用方 yield 完 events 后须立即退出
+ * converse() 生成器（等效于原 switch 中的 `return`）。
+ */
+function dispatchResponsesSSEEvent(
+  type: string | undefined,
+  data: Record<string, unknown>,
+  state: ResponsesStreamState,
+): { events: StreamEvent[]; fatal: boolean } {
+  switch (type) {
+    case 'response.output_item.added': {
+      const index = (data.output_index as number) ?? 0
+      const item = data.item as Record<string, unknown> | undefined
+      if (item?.type === 'function_call') {
+        state.blocks.set(index, {
+          kind: 'tool_call',
+          id: (item.call_id as string) ?? (item.id as string) ?? `call_${index}`,
+          name: (item.name as string) ?? '',
+          argumentsJson: '',
+        })
+        return { events: [{ type: 'tool_call_start', index, partial: buildAssistantMessage(state) }], fatal: false }
+      } else if (item?.type === 'reasoning') {
+        ensureBlock(state.blocks, index, 'thinking')
+        return { events: [{ type: 'thinking_start', index, partial: buildAssistantMessage(state) }], fatal: false }
+      } else if (item?.type === 'message') {
+        ensureBlock(state.blocks, index, 'text')
+        return { events: [{ type: 'text_start', index, partial: buildAssistantMessage(state) }], fatal: false }
+      }
+      return { events: [], fatal: false }
+    }
+
+    case 'response.output_text.delta': {
+      const index = (data.output_index as number) ?? 0
+      const delta = (data.delta as string) ?? ''
+      const block = ensureBlock(state.blocks, index, 'text')
+      if (block.kind === 'text') {
+        block.text += delta
+        return { events: [{ type: 'text_delta', index, delta, partial: buildAssistantMessage(state) }], fatal: false }
+      }
+      return { events: [], fatal: false }
+    }
+
+    case 'response.reasoning_summary_text.delta':
+    case 'response.reasoning_text.delta': {
+      const index = (data.output_index as number) ?? 0
+      const delta = (data.delta as string) ?? ''
+      const block = ensureBlock(state.blocks, index, 'thinking')
+      if (block.kind === 'thinking') {
+        block.text += delta
+        return { events: [{ type: 'thinking_delta', index, delta, partial: buildAssistantMessage(state) }], fatal: false }
+      }
+      return { events: [], fatal: false }
+    }
+
+    case 'response.function_call_arguments.delta': {
+      const index = (data.output_index as number) ?? 0
+      const delta = (data.delta as string) ?? ''
+      const block = state.blocks.get(index)
+      if (block?.kind === 'tool_call') {
+        block.argumentsJson += delta
+        return { events: [{ type: 'tool_call_delta', index, delta, partial: buildAssistantMessage(state) }], fatal: false }
+      }
+      return { events: [], fatal: false }
+    }
+
+    case 'response.completed':
+    case 'response.incomplete': {
+      const response = data.response as Record<string, unknown> | undefined
+      const usage = response?.usage as Record<string, unknown> | undefined
+      if (usage) {
+        const inputTokens = (usage.input_tokens as number) ?? 0
+        const outputTokens = (usage.output_tokens as number) ?? 0
+        const cached =
+          (usage.input_tokens_details as Record<string, number> | undefined)?.cached_tokens ??
+          0
+        state.inputTokens = inputTokens - cached
+        state.outputTokens = outputTokens
+        state.cacheReadTokens = cached
+      }
+      const hasTool = [...state.blocks.values()].some((b) => b.kind === 'tool_call')
+      if (type === 'response.incomplete') {
+        state.stopReason = 'max_tokens'
+      } else {
+        state.stopReason = hasTool ? 'tool_use' : 'end_turn'
+      }
+      return { events: [], fatal: false }
+    }
+
+    case 'response.failed':
+    case 'error': {
+      const response = data.response as Record<string, unknown> | undefined
+      const errObj = (response?.error ?? data.error) as Record<string, unknown> | undefined
+      const message = (errObj?.message as string) ?? 'OpenAI Responses stream error'
+      // OpenAI 错误体形如 { message, type, code, param }（如 type:'invalid_request_error',
+      // code:'invalid_api_key'）——code 比 type 更具体，优先取 code，回退 type（同 Anthropic
+      // errorType 语义：供应商机器可读的失效根因分类，非 otto 内部 code）。
+      const errorType =
+        (errObj?.code as string | undefined) ?? (errObj?.type as string | undefined)
+      return {
+        events: [{
+          type: 'error',
+          error: new ProviderError(`OpenAI Responses API error: ${message}`, {
+            code: 'PROVIDER_API_ERROR',
+            errorType,
+          }),
+        }],
+        fatal: true,
+      }
+    }
+
+    default:
+      return { events: [], fatal: false }
+  }
+}
+
+class OpenAIResponsesStream implements ProviderStream {
+  readonly id = 'openai-responses'
+  readonly displayName = 'OpenAI'
+
+  constructor(
+    private readonly resolveCredential?: OpenAIResponsesCredentialResolver,
+    private readonly baseUrlResolver?: OpenAIResponsesBaseUrlResolver,
+    private readonly tokenDerivedHeaders?: TokenDerivedHeader[],
+    /**
+     * 终局 review 2026-07-10 P1-7：静态额外 headers（如 vendor 自定义头），对齐
+     * `OpenAICompletionsProviderOptions.headers` 已有模式——此前本类没有这个字段，
+     * `openai-codex-responses` 的 `originator` 头只能靠 wire 内部硬编码分支实现，
+     * 与 `plugin-openai-codex/otto-plugin.json` 里 `contributes.providers[0].headers`
+     * 的声明形成"双份真相"（manifest 声明了但从未被消费，硬编码才是唯一生效路径）。
+     * 补齐此字段后硬编码分支已冗余，随本次一并删除（见下方 buildHeaders）。
+     */
+    private readonly staticHeaders?: Record<string, string>,
+    private readonly logger: WireProtocolLogger = noopLogger,
+    /** 见 `OpenAIResponsesProviderOptions.customizeRequest`。缺省 = 零定制。 */
+    private readonly customizeRequest?: (input: WireRequestCustomizeInput) => WireRequestCustomization,
+    private readonly allowAuthHeaderOverride?: boolean,
+  ) {}
+
+  /**
+   * 进程内稳定的会话 id——供 `customizeRequest` 定制器使用（对齐 anthropic-messages
+   * 的同名字段，RFC-270 D2 终局 review F2：此前本协议无 sessionId，钩子入参无法构造）。
+   */
+  private readonly requestSessionId = randomUUID()
+
+  /** 统一鉴权解析（RFC-140 D5，`ProviderStream.resolveAuth`）——OpenAI Responses 恒 api_key 模式。 */
+  async resolveAuth(): Promise<ResolvedAuth> {
+    if (this.resolveCredential) {
+      const key = await this.resolveCredential()
+      if (key) {
+        return { token: key, mode: 'api_key' }
+      }
+    }
+
+    const envKey = process.env['OPENAI_API_KEY']
+    if (envKey) {
+      return { token: envKey, mode: 'api_key' }
+    }
+
+    throw new ProviderError('Missing OpenAI credential. Set OPENAI_API_KEY or login via OAuth.', {
+      code: 'PROVIDER_AUTH_MISSING',
+    })
+  }
+
+  private async resolveBaseUrl(model: Model): Promise<string> {
+    const envUrl = process.env['OPENAI_BASE_URL']
+    if (envUrl) {
+      return envUrl
+    }
+    if (this.baseUrlResolver) {
+      const url = await this.baseUrlResolver()
+      if (url) {
+        return url
+      }
+    }
+    return model.baseUrl
+  }
+
+  /**
+   * RFC-270 D1：头组装收敛到 @x-otto/provider 的统一管线（此前本方法自行合并，且注释声称
+   * 与 openai-completions.ts 顺序一致——实为相反，是无人察觉的漂移）。鉴权头 write-last
+   * 不可被 ②③④ 档覆盖，除非 provider 显式声明 allowAuthHeaderOverride。
+   */
+  private buildHeaders(auth: ResolvedAuth, providerLabel: string): Record<string, string> {
+    const customization = this.customizeRequest?.({
+      auth: { mode: auth.mode, beta: auth.beta },
+      sessionId: this.requestSessionId,
+    })
+
+    return buildRequestHeaders({
+      staticHeaders: this.staticHeaders,
+      tokenDerived: this.tokenDerivedHeaders?.length
+        ? { headers: this.tokenDerivedHeaders, token: auth.token }
+        : undefined,
+      customized: customization?.defaultHeaders,
+      auth: { authorization: `Bearer ${auth.token}` },
+      allowAuthHeaderOverride: this.allowAuthHeaderOverride,
+      logger: this.logger,
+      diagnosticLabel: `openai-responses:${providerLabel}`,
+    })
+  }
+
+  async *converse(
+    model: Model,
+    context: StreamContext,
+    options: StreamOptions,
+    signal: AbortSignal,
+  ): AsyncIterable<StreamEvent> {
+    const auth = await this.resolveAuth()
+    const baseUrl = await this.resolveBaseUrl(model)
+    const url = `${baseUrl}/responses`
+    const body = buildResponsesBody(model, context)
+
+    this.logger.debug({ model: model.id }, 'Starting OpenAI Responses stream')
+
+    const state = initStreamState(model)
+    let started = false
+
+    try {
+      // ChatGPT Codex 后端响应 headers 暂存闭包——onResponse 在 fetch 成功后立即同步触发
+      //（http.ts stream() 在 response.ok 后、读 body 前调用），保存下来的 headers 在 done
+      // 事件 yield 时读取（此时 fetch 已结束，但 headers 对象的引用仍然存活）。
+      let responseHeaders: Headers | undefined
+      const sse = stream({
+        url,
+        body,
+        headers: this.buildHeaders(auth, model.provider),
+        signal,
+        timeout: options.timeout ?? 300000,
+        onResponse: (h) => {
+          responseHeaders = h
+        },
+      })
+
+      for await (const ev of sse) {
+        if (ev.data === '[DONE]') {
+          break
+        }
+
+        let data: Record<string, unknown>
+        try {
+          data = JSON.parse(ev.data) as Record<string, unknown>
+        } catch {
+          this.logger.warn('Failed to parse Responses SSE data')
+          continue
+        }
+
+        if (!started) {
+          started = true
+          yield { type: 'start', partial: buildAssistantMessage(state) }
+        }
+
+        const type = ev.event ?? (data.type as string | undefined)
+        const result = dispatchResponsesSSEEvent(type, data, state)
+        yield* result.events
+        if (result.fatal) return
+      }
+
+      const orderedTools = [...state.blocks.entries()].sort(([a], [b]) => a - b)
+      for (const [index, block] of orderedTools) {
+        if (block.kind === 'tool_call') {
+          yield {
+            type: 'tool_call_end',
+            index,
+            toolCall: toolCallFromParsed(block.id, block.name, block.argumentsJson),
+            partial: buildAssistantMessage(state),
+          }
+        } else if (block.kind === 'text') {
+          // 补 text_end（缺 end 会致完成通知空 + 投影缺口）。
+          yield { type: 'text_end', index, content: block.text, partial: buildAssistantMessage(state) }
+        } else if (block.kind === 'thinking') {
+          yield {
+            type: 'thinking_end',
+            index,
+            content: block.text,
+            partial: buildAssistantMessage(state),
+          }
+        }
+      }
+
+      yield {
+          type: 'done',
+          reason: state.stopReason,
+          // RFC-232（终局修正）：跨 wire 协议救回违约响应，见 @x-otto/provider stream-state.ts。
+          message: recoverLiteralInvokeToolCalls(buildAssistantMessage(state, true), registeredToolNames(context.tools)),
+          providerUsage: extractStandardRateLimitHeaders(responseHeaders),
+        }
+    } catch (error) {
+      if (error instanceof Error) {
+        yield { type: 'error', error }
+      } else {
+        yield {
+          type: 'error',
+          error: new ProviderError('Unknown OpenAI Responses stream error', {
+            code: 'PROVIDER_STREAM_ERROR',
+          }),
+        }
+      }
+    }
+  }
+}
+
+export interface OpenAIResponsesProviderOptions {
+  resolveKey?: OpenAIResponsesCredentialResolver
+  resolveBaseUrl?: OpenAIResponsesBaseUrlResolver
+  /** RFC-122 D3：插件声明式 token 派生 header（provider-loader 装载时注入） */
+  tokenDerivedHeaders?: TokenDerivedHeader[]
+  /**
+   * 终局 review 2026-07-10 P1-7：静态额外 headers（如 codex 插件声明的 `originator`），
+   * 对齐 `OpenAICompletionsProviderOptions.headers` 已有模式。
+   */
+  headers?: Record<string, string>
+  /**
+   * RFC-270 D2：程序化请求定制点（拦截器）。此前只有 anthropic-messages 消费该钩子，
+   * 本协议补齐——返回的 `defaultHeaders` 并入头管线第 ④ 档。`transformSystemBlocks`
+   * 不适用于本协议，按 `WireRequestCustomization` 契约忽略。
+   */
+  customizeRequest?: (input: WireRequestCustomizeInput) => WireRequestCustomization
+  /** RFC-270 D3：manifest 显式声明后，允许自定义头覆盖鉴权头（企业网关换鉴权）。 */
+  allowAuthHeaderOverride?: boolean
+  /** RFC-185 D3：宿主注入的日志端口，缺省 no-op。 */
+  logger?: WireProtocolLogger
+}
+
+export function createOpenAIResponsesProvider(
+  options: OpenAIResponsesProviderOptions = {},
+): ProviderStream {
+  return new OpenAIResponsesStream(
+    options.resolveKey,
+    options.resolveBaseUrl,
+    options.tokenDerivedHeaders,
+    options.headers,
+    options.logger,
+    options.customizeRequest,
+    options.allowAuthHeaderOverride,
+  )
+}

package/dist/bundled-extensions/plugin-skill-inductor/otto-plugin.json

@@ -0,0 +1,8 @@
+{
+  "id": "plugin-skill-inductor",
+  "name": "Skill Inductor",
+  "version": "0.1.0",
+  "description": "Observes completed task trajectories and distills them into structured episodes — the data source for auto-induced skills (RFC-318 skill loop).",
+  "capabilities": ["service", "storage", "session.read", "llm.complete", "user.notify"],
+  "scripts": { "postinstall": "otto extension build" }
+}

package/dist/bundled-extensions/plugin-skill-inductor/plugin-dist/meta.json

@@ -0,0 +1 @@
+{"apiVersion":1,"compilerVersion":"0.1.0-alpha.1","sourceHash":"5b28454cfded236868d7031600579b7aa59f72785a003a28034b3cb81c5b70ae"}