@oomol-lab/open-flow 0.1.0-beta.84 → 0.1.0-beta.86

package/src/flow/common/change.ts

@@ -166,6 +166,7 @@ export interface ConditionNode extends GraphNodeBase {
 }
 
 export type ManagedTaskExecutor =
+  | import('../../connector/common/proxy.ts').ConnectorProxyExecutor
   | import('../../http/common/httpRequest.ts').HttpRequestExecutor
   | import('../../state/common/state.ts').SkipDuplicatesExecutor
   | WorkflowExecutor
@@ -398,7 +399,7 @@ export interface FlowDocument {
 
 export interface RevisionContent {
   readonly document: FlowDocument
-  readonly modelVersion: 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | typeof currentFlowModelVersion
+  readonly modelVersion: 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | typeof currentFlowModelVersion
   readonly modules: Readonly<Record<string, CodeModule>>
 }
 

package/src/flow/common/changeSchema.ts

@@ -2,6 +2,7 @@ import type { ChangeOperation, FlowDocument, JsonValue, RevisionContent } from '
 
 import { dequal } from 'dequal/lite'
 import { z } from 'zod'
+import { connectorProxyExecutorSchema } from '../../connector/common/proxy.ts'
 import { limitDecisionTask } from '../../decision/common/decision.ts'
 import { assertHttpAuthBindings } from '../../http/common/authBindings.ts'
 import { isHttpHost, maxHttpHosts } from '../../http/common/hosts.ts'
@@ -14,7 +15,7 @@ import { waitAutoContinueDraftSchema, waitAutoContinueSchema } from './wait.ts'
 import { webhookMethods } from './webhookMethod.ts'
 import { webhookResponseTimeout } from './webhookResponse.ts'
 
-export const currentFlowModelVersion = 13
+export const currentFlowModelVersion = 14
 const text = z.string()
 const actionConnection = text.describe(
   'Account selection: omit while unconfigured; use an account ID to select it; use "" to explicitly defer configuration. Deferred Actions fail if called; deferred Agent tools are excluded from the callable tool set. Not supported by Triggers.',
@@ -131,6 +132,7 @@ const managedFields = z.object({
     z.strictObject({ kind: z.literal('workflow'), flowId: text, revisionId: text }),
     httpRequestExecutorSchema,
     skipDuplicatesExecutorSchema,
+    connectorProxyExecutorSchema,
   ]),
 })
 
@@ -321,6 +323,7 @@ const revision = z.object({
     z.literal(10),
     z.literal(11),
     z.literal(12),
+    z.literal(13),
     z.literal(currentFlowModelVersion),
   ]),
   document,
@@ -726,6 +729,13 @@ export function changeOperationsSchema(kind?: string): JsonValue {
 }
 
 function checkModelVersion(content: RevisionContent): void {
+  if (
+    content.modelVersion < 14 &&
+    Object.values(content.document.graph.nodes).some(
+      (candidateNode) => candidateNode.kind === 'task' && 'executor' in candidateNode.task && candidateNode.task.executor.kind === 'connector-proxy',
+    )
+  )
+    throw new TypeError('Custom API Request requires Flow model v14.')
   if (
     content.modelVersion < 13 &&
     Object.values(content.document.graph.nodes).some(

package/src/flow/common/connectionUsage.ts

@@ -8,7 +8,7 @@ export interface ConnectionUsage {
   readonly nodeId: string
   readonly name: string
 
-  readonly kind: 'connector' | 'agent' | 'trigger' | 'notification' | 'code'
+  readonly kind: 'connector' | 'connector-proxy' | 'agent' | 'trigger' | 'notification' | 'code'
 }
 
 export function connectionUsage(document: FlowDocument): readonly ConnectionUsage[] {
@@ -31,6 +31,8 @@ export function connectionUsage(document: FlowDocument): readonly ConnectionUsag
       })
     }
     if (task?.executor.kind == 'connector') add('connector', task.executor.action, task.executor.connectionId)
+    if (task?.executor.kind == 'connector-proxy')
+      uses.push({ kind: 'connector-proxy', providerId: task.executor.providerId, connectionId: task.executor.connectionId, nodeId, name })
     if (node.kind == 'task' && 'moduleId' in node.task) {
       for (const capability of node.task.capabilities ?? []) {
         if ('mode' in capability && capability.mode == 'independent') for (const action of capability.actions) add('code', action.action, action.connectionId)
@@ -74,7 +76,7 @@ export function clearNodeConnections(graph: FlowDocument['graph'], connectionId?
             const { connectionId: _, ...rest } = value
             return rest as T
           }
-          if (executor.kind == 'connector') return [id, { ...node, task: { ...node.task, executor: clear(executor) } }]
+          if (executor.kind == 'connector' || executor.kind == 'connector-proxy') return [id, { ...node, task: { ...node.task, executor: clear(executor) } }]
           if (executor.kind == 'agent')
             return [
               id,

package/src/flow/common/errorHandling.ts

@@ -26,7 +26,9 @@ export const nodeErrorSchema = {
 } as const
 
 export function supportsNodeErrorHandling(node: GraphNode): boolean {
-  return supportsNodeRetry(node) || (node.kind === 'task' && 'executor' in node.task && node.task.executor.kind === 'skip-duplicates')
+  return (
+    supportsNodeRetry(node) || (node.kind === 'task' && 'executor' in node.task && ['skip-duplicates', 'connector-proxy'].includes(node.task.executor.kind))
+  )
 }
 
 export function nodeSystemOutputPorts(node: GraphNode): Readonly<Record<string, PortDefinition>> {

package/src/flow/common/nodeChanges.ts

@@ -22,6 +22,7 @@ import type {
 } from './change.ts'
 
 import { dequal } from 'dequal/lite'
+import { connectorProxyHasBody, connectorProxyTask } from '../../connector/common/proxy.ts'
 import { decisionTask } from '../../decision/common/decision.ts'
 import { isTriggerNode, applyFlowChanges, nextNodeName, normalizeNodeName } from './change.ts'
 import { codeSharedPermissionsEnabled } from './codePermissions.ts'
@@ -401,13 +402,37 @@ export function setInputValues(
   content: RevisionContent,
   nodeId: string,
   values: Readonly<Record<string, JsonValue | undefined>>,
+): readonly ChangeOperation[] | undefined {
+  return setInputMappings(content, nodeId, Object.fromEntries(Object.entries(values).map(([handle, value]) => [handle, fixedInputValue(value)])))
+}
+
+/** Input sources own whether a Provider request includes a body and its generated port. */
+export function setInputMappings(
+  content: RevisionContent,
+  nodeId: string,
+  mappings: Readonly<Record<string, InputMapping | undefined>>,
 ): readonly ChangeOperation[] | undefined {
   const node = content.document.graph?.nodes[nodeId]
   if (node == null || isTriggerNode(node)) return
   const operations: ChangeOperation[] = []
-  for (const [handle, value] of Object.entries(values)) {
+  const task = node.kind === 'task' && 'executor' in node.task && node.task.executor.kind === 'connector-proxy' ? node.task : undefined
+  let bodyUndeclared = false
+  if (task?.executor.kind === 'connector-proxy' && Object.hasOwn(mappings, 'body')) {
+    const port = task.inputs.find((input): input is InputPort => 'handle' in input && input.handle === 'body')
+    const hasBody = connectorProxyHasBody(mappings.body, port?.value)
+    bodyUndeclared = !hasBody && task.executor.bodyFormat === 'none'
+    if (hasBody && task.executor.bodyFormat === 'none') {
+      operations.push({
+        kind: 'graph.node.task.set',
+        nodeId,
+        before: task,
+        value: connectorProxyTask({ ...task.executor, bodyFormat: 'json' }, task.name, task),
+      })
+    }
+  }
+  for (const [handle, value] of Object.entries(mappings)) {
     const before = nodeInputMappings(node)[handle]
-    const next = fixedInputValue(value)
+    const next = handle === 'body' && bodyUndeclared ? undefined : value
     if (dequal(before, next)) continue
     operations.push({ before, handle, kind: 'graph.node.input.set', nodeId, value: next })
   }
@@ -418,13 +443,7 @@ export function setInputValues(
 export function resetInputValues(content: RevisionContent, nodeId: string, handles: readonly string[]): readonly ChangeOperation[] {
   const node = content.document.graph?.nodes[nodeId]
   if (node == null || isTriggerNode(node)) return []
-  const mappings = nodeInputMappings(node)
-  return cleanVariableBindings(
-    content,
-    [...new Set(handles)].flatMap((handle): ChangeOperation[] =>
-      mappings[handle] == null ? [] : [{ kind: 'graph.node.input.set', nodeId, handle, before: mappings[handle], value: undefined }],
-    ),
-  )
+  return setInputMappings(content, nodeId, Object.fromEntries(handles.map((handle) => [handle, undefined]))) ?? []
 }
 
 export function setInputSources(
@@ -435,9 +454,7 @@ export function setInputSources(
 ): readonly ChangeOperation[] {
   const node = content.document.graph?.nodes[nodeId]
   if (node == null || isTriggerNode(node)) return []
-  return cleanVariableBindings(content, [
-    { kind: 'graph.node.input.set', nodeId, handle, before: nodeInputMappings(node)[handle], value: { kind: 'sources', sources } },
-  ])
+  return setInputMappings(content, nodeId, { [handle]: { kind: 'sources', sources } }) ?? []
 }
 
 export function setInputVariable(
@@ -459,10 +476,7 @@ export function setInputVariable(
     return [{ before: current.target, bindingId: currentId, kind: 'binding.target.set', value: name }]
   }
   const next: InputMapping = { kind: 'sources', sources: [{ bindingId, kind: 'binding' }] }
-  return [
-    { binding: { kind: 'variable', target: name }, bindingId, kind: 'binding.create' },
-    ...cleanVariableBindings(content, [{ before: mapping, handle, kind: 'graph.node.input.set', nodeId, value: next }]),
-  ]
+  return [{ binding: { kind: 'variable', target: name }, bindingId, kind: 'binding.create' }, ...(setInputMappings(content, nodeId, { [handle]: next }) ?? [])]
 }
 
 export function cleanVariableBindings(content: RevisionContent, operations: readonly ChangeOperation[]): readonly ChangeOperation[] {
@@ -495,9 +509,9 @@ function bindingReferences(document: RevisionContent['document']): Map<string, n
 
 export function setConnectorConnection(content: RevisionContent, nodeId: string, connectionId: string | undefined): readonly ChangeOperation[] | undefined {
   const node = content.document.graph.nodes[nodeId]
-  if (node?.kind != 'task' || !('executor' in node.task) || node.task.executor.kind != 'connector') return
+  if (node?.kind != 'task' || !('executor' in node.task) || (node.task.executor.kind != 'connector' && node.task.executor.kind != 'connector-proxy')) return
   const task = node.task
-  if (task.executor.kind != 'connector') return
+  if (task.executor.kind != 'connector' && task.executor.kind != 'connector-proxy') return
   if (task.executor.connectionId == connectionId) return []
   const { connectionId: _, ...executor } = task.executor
   return [
@@ -542,6 +556,9 @@ export function setServiceConnections(
       if (capabilities != null) operations.push(...(setCodeActions(content, nodeId, capabilities) ?? []))
     } else if (task.executor.kind == 'connector') {
       if (assign(task.executor) !== task.executor) operations.push(...(setConnectorConnection(content, nodeId, connectionId) ?? []))
+    } else if (task.executor.kind === 'connector-proxy') {
+      if (task.executor.providerId === providerId && task.executor.connectionId === previousConnectionId)
+        operations.push(...(setConnectorConnection(content, nodeId, connectionId) ?? []))
     } else if (task.executor.kind == 'agent') {
       const executor = {
         ...task.executor,

package/src/flow/common/requestParameters.ts

@@ -0,0 +1,120 @@
+import type { InputMapping, InputPort, JsonValue, TaskDefinitionBase, TaskExecutor } from './model.ts'
+
+import { dequal } from 'dequal/lite'
+import { z } from 'zod'
+import { httpHeaderNameIssue } from '../../http/common/headers.ts'
+import { remapInputMappings, renamedPort } from './portChanges.ts'
+
+export const requestParameterSchema = z.strictObject({ mode: z.enum(['fields', 'object']).default('fields'), names: z.array(z.string()).default([]) })
+export type RequestParameters = z.infer<typeof requestParameterSchema>
+export interface RequestParameterConfig {
+  readonly query: RequestParameters
+  readonly headers: RequestParameters
+}
+export interface RequestTaskNode {
+  readonly inputs: Readonly<Record<string, InputMapping>>
+  readonly task: TaskDefinitionBase & { readonly executor?: TaskExecutor }
+}
+
+export function requestParameterHandle(group: 'query' | 'headers', name: string): string {
+  return `${group === 'query' ? 'query' : 'header'}.${name}`
+}
+
+export function requestParameterPorts(
+  config: RequestParameterConfig,
+  querySchema: JsonValue,
+  queryValueSchema: JsonValue,
+  headerSchema: JsonValue,
+): InputPort[] {
+  return (['query', 'headers'] as const).flatMap((group): InputPort[] =>
+    config[group].mode === 'object'
+      ? [{ handle: group, jsonSchema: group === 'query' ? querySchema : headerSchema, nullable: true }]
+      : config[group].names
+          .filter((name) => name.trim())
+          .map((name) => ({
+            handle: requestParameterHandle(group, name),
+            jsonSchema: group === 'query' ? queryValueSchema : { type: 'string' },
+            nullable: true,
+          })),
+  )
+}
+
+export function retainRequestPorts(ports: readonly InputPort[], old: TaskDefinitionBase['inputs'] = []): TaskDefinitionBase['inputs'] {
+  const remaining = new Map(ports.map((port) => [port.handle, port]))
+  return [
+    ...old.flatMap((item): TaskDefinitionBase['inputs'] => {
+      if ('group' in item) return [item]
+      const next = remaining.get(item.handle)
+      if (next == null) return []
+      remaining.delete(item.handle)
+      return [dequal(item.jsonSchema, next.jsonSchema) && item.nullable == next.nullable ? item : next]
+    }),
+    ...remaining.values(),
+  ]
+}
+
+export interface RequestParameterIssue {
+  readonly field: 'query' | 'headers'
+  readonly index: number
+  readonly code: 'parameterNamesInvalid' | 'headerNameInvalid'
+  readonly message: string
+}
+
+export function requestParameterIssues(config: RequestParameterConfig): RequestParameterIssue[] {
+  const issues: RequestParameterIssue[] = []
+  for (const group of ['query', 'headers'] as const) {
+    if (config[group].mode !== 'fields') continue
+    const seen = new Set<string>()
+    for (const [index, name] of config[group].names.entries()) {
+      const key = group === 'headers' ? name.toLowerCase() : name
+      if (!name.trim() || seen.has(key))
+        issues.push({ field: group, index, code: 'parameterNamesInvalid', message: 'Parameter names must be nonempty and unique.' })
+      seen.add(key)
+      if (group === 'headers' && httpHeaderNameIssue(name, []) === 'invalid')
+        issues.push({ field: group, index, code: 'headerNameInvalid', message: 'Invalid HTTP header name.' })
+    }
+  }
+  return issues
+}
+
+/** Only a named parameter rename carries a source; changing modes does not rename a port. */
+export function requestInputMappings(
+  mappings: Readonly<Record<string, InputMapping>>,
+  previous: TaskDefinitionBase,
+  next: TaskDefinitionBase,
+): Record<string, InputMapping> {
+  const candidate = renamedPort(previous.inputs, next.inputs)
+  const rename = candidate != null && ['query.', 'header.'].some((prefix) => candidate.every((name) => name.startsWith(prefix))) ? candidate : undefined
+  return remapInputMappings(mappings, next.inputs, rename)
+}
+
+export function withRequestParameterFields<Node extends RequestTaskNode>(
+  node: Node,
+  group: 'query' | 'headers',
+  values: Record<string, JsonValue>,
+  previous: RequestParameters,
+  createTask: (parameters: RequestParameters) => Node['task'],
+): Node {
+  const task = createTask({ mode: 'fields', names: Object.keys(values) })
+  const inputs = requestInputMappings(node.inputs, node.task, task)
+  const rename = renamedPort(node.task.inputs, task.inputs)
+  for (const [name, value] of Object.entries(values)) {
+    const handle = requestParameterHandle(group, name)
+    const existing = previous.mode === 'fields' && (previous.names.includes(name) || rename?.[1] === handle)
+    if (inputs[handle] == null && !existing) inputs[handle] = { kind: 'value', value }
+  }
+  return { ...node, task, inputs }
+}
+
+export function withRequestParameterSource<Node extends RequestTaskNode>(
+  node: Node,
+  group: 'query' | 'headers',
+  mapping: InputMapping | undefined,
+  createTask: (parameters: RequestParameters) => Node['task'],
+): Node {
+  const task = createTask({ mode: 'object', names: [] })
+  const inputs = requestInputMappings(node.inputs, node.task, task)
+  if (mapping == null) delete inputs[group]
+  else inputs[group] = mapping
+  return { ...node, task, inputs }
+}

package/src/flow/common/semantics.ts

@@ -1,5 +1,6 @@
 import { dequal } from 'dequal/lite'
 import { connectorActionContracts } from '../../connector/common/actionContract.ts'
+import { connectorProxyHasBody, connectorProxyIssues, connectorProxyTask } from '../../connector/common/proxy.ts'
 import { decisionTaskIssues } from '../../decision/common/decision.ts'
 import { httpRequestIssues, httpAuthHandles, httpRequestTask, httpRequestUrl } from '../../http/common/httpRequest.ts'
 import { openApiIssues, authHandles } from '../../openapi/common/openapi.ts'
@@ -14,7 +15,17 @@ import { connectionUsage } from './connectionUsage.ts'
 export { matchesTriggerOutputs, normalizeTriggerOutputs, triggerOutputDefinitions, triggerOutputPorts } from '../../trigger/common/contract.ts'
 import type { EngineContract } from '../../runtime/common/engineContract.ts'
 import type { RuntimeProgram } from '../../runtime/common/runtime.ts'
-import type { ConnectorActionCapability, ConnectorCapability, Graph, InputMapping, JsonValue, Port, RevisionContent, SchemaMismatch } from './change.ts'
+import type {
+  ConnectorActionCapability,
+  ConnectorCapability,
+  Graph,
+  InputMapping,
+  InputPort,
+  JsonValue,
+  Port,
+  RevisionContent,
+  SchemaMismatch,
+} from './change.ts'
 
 import { findEngineContract } from '../../runtime/common/engineContract.ts'
 import { agentConfigIssues } from './agent.ts'
@@ -289,6 +300,38 @@ export async function validateFlow(revision: RevisionContent, engine: EngineCont
           path: `/document/graph/nodes/${nodeId}/task`,
         })
     }
+    if (task.executor.kind === 'connector-proxy') {
+      const endpoint = node.inputs.endpoint
+      if (endpoint?.kind === 'value' && (typeof endpoint.value !== 'string' || !endpoint.value.trim()))
+        checked.diagnostics.push({
+          code: 'connector-proxy.endpoint-invalid',
+          column: 0,
+          line: 0,
+          message: 'A nonempty endpoint is required.',
+          path: `/document/graph/nodes/${nodeId}/inputs/endpoint`,
+        })
+      const bodyPort = task.inputs.find((port): port is InputPort => 'handle' in port && port.handle === 'body')
+      for (const issue of connectorProxyIssues(task.executor, connectorProxyHasBody(node.inputs.body, bodyPort?.value)))
+        checked.diagnostics.push({
+          code: 'connector-proxy.config-invalid',
+          column: 0,
+          line: 0,
+          message: issue.message,
+          path: issue.field === 'bodyFormat' ? `/document/graph/nodes/${nodeId}/inputs/body` : `/document/graph/nodes/${nodeId}/task/executor/${issue.field}`,
+        })
+      const expected = connectorProxyTask(task.executor)
+      if (
+        !dequal(httpPortContracts(task.inputs), httpPortContracts(expected.inputs)) ||
+        !dequal(httpPortContracts(task.outputs), httpPortContracts(expected.outputs))
+      )
+        checked.diagnostics.push({
+          code: 'connector-proxy.ports-invalid',
+          column: 0,
+          line: 0,
+          message: 'Provider API request ports do not match their configuration.',
+          path: `/document/graph/nodes/${nodeId}/task`,
+        })
+    }
     if (task.executor.kind == 'http-request') {
       for (const issue of httpRequestIssues(task.executor))
         checked.diagnostics.push({
@@ -458,6 +501,13 @@ const httpPortContracts = (ports: import('./change.ts').ManagedTaskDefinition['i
 export async function prepareFlow(revision: RevisionContent, engineContract: string, triggerId?: string): Promise<PrepareFlowResult> {
   const engine = findEngineContract(engineContract)
   if (engine == null) return { kind: 'engine-unsupported' }
+  if (
+    !engine.connectorProxy &&
+    Object.values(revision.document.graph.nodes).some(
+      (node) => node.kind === 'task' && 'executor' in node.task && node.task.executor.kind === 'connector-proxy',
+    )
+  )
+    return { kind: 'engine-unsupported' }
   if (
     !engine.flowState &&
     Object.values(revision.document.graph.nodes).some(

package/src/flow/common/sourceField.ts

@@ -1,5 +1,6 @@
-import type { NodeSource, PortDefinition } from './change.ts'
+import type { JsonValue, NodeSource, PortDefinition } from './change.ts'
 
+import { propertySchemaWithDefinitions } from '../../base/common/jsonSchema.ts'
 import { schemaObject } from './schema.ts'
 
 /** Only explicitly declared, first-level object properties are selectable. */
@@ -17,7 +18,7 @@ export function sourceFields(output: PortDefinition): readonly { readonly field:
       field,
       port: {
         ...(typeof description == 'string' ? { description } : {}),
-        jsonSchema,
+        jsonSchema: propertySchemaWithDefinitions(schema, jsonSchema) as JsonValue,
         nullable: missingParent || !required.includes(field),
       },
     }

package/src/flow/common/workflowFile.ts

@@ -86,8 +86,8 @@ export function cleanWorkflowFile(value: unknown): { readonly file: WorkflowFile
   }
 }
 
-export function encodeWorkflowFile(file: WorkflowFile): string {
-  return `${JSON.stringify(cleanWorkflowFile(file).file, null, 2)}\n`
+export function encodeWorkflowFile(file: WorkflowFile, options: { readonly clean?: boolean } = {}): string {
+  return `${JSON.stringify(options.clean === false ? decodeWorkflowFile(file) : cleanWorkflowFile(file).file, null, 2)}\n`
 }
 
 export function workflowFileName(name: string): string {

package/src/http/common/httpRequest.ts

@@ -1,17 +1,24 @@
-import type { InputMapping, InputPort, JsonValue, ManagedTaskDefinitionOf, TaskDefinitionBase, TaskExecutor } from '../../flow/common/model.ts'
+import type { InputMapping, InputPort, JsonValue, ManagedTaskDefinitionOf, TaskDefinitionBase } from '../../flow/common/model.ts'
+import type { RequestTaskNode } from '../../flow/common/requestParameters.ts'
 
-import { dequal } from 'dequal/lite'
 import { z } from 'zod'
-import { remapInputMappings, renamedPort } from '../../flow/common/portChanges.ts'
+import {
+  requestParameterSchema,
+  requestParameterPorts,
+  requestParameterIssues,
+  requestInputMappings,
+  retainRequestPorts,
+  withRequestParameterFields,
+  withRequestParameterSource,
+} from '../../flow/common/requestParameters.ts'
 import { httpHeaderNameIssue } from './headers.ts'
 
 export { httpHostAllowed, isHttpHost, maxHttpHosts } from './hosts.ts'
 
-const parameterSchema = z.strictObject({ mode: z.enum(['fields', 'object']).default('fields'), names: z.array(z.string()).default([]) })
 export const httpRequestConfigSchema = z.strictObject({
   method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']).default('GET'),
-  query: parameterSchema.default({ mode: 'fields', names: [] }),
-  headers: parameterSchema.default({ mode: 'fields', names: [] }),
+  query: requestParameterSchema.default({ mode: 'fields', names: [] }),
+  headers: requestParameterSchema.default({ mode: 'fields', names: [] }),
   bodyFormat: z.enum(['none', 'json', 'text', 'form']).default('none'),
   authentication: z
     .union([
@@ -36,36 +43,15 @@ export const httpQuerySchema = { type: 'object', additionalProperties: queryValu
 export function httpAuthHandles(config: HttpRequestConfig): string[] {
   return config.authentication.type == 'none' ? [] : config.authentication.type == 'basic' ? ['auth.username', 'auth.password'] : ['auth.token']
 }
-// Preserve metadata on ports whose contracts did not change.
-function retain(ports: readonly InputPort[], old: TaskDefinitionBase['inputs']): TaskDefinitionBase['inputs'] {
-  const remaining = new Map(ports.map((port) => [port.handle, port]))
-  return [
-    ...old.flatMap((item): TaskDefinitionBase['inputs'] => {
-      if ('group' in item) return [item]
-      const next = remaining.get(item.handle)
-      if (next == null) return []
-      remaining.delete(item.handle)
-      return [dequal(item.jsonSchema, next.jsonSchema) && item.nullable == next.nullable ? item : next]
-    }),
-    ...remaining.values(),
-  ]
-}
 export function httpRequestTask(
   config: HttpRequestConfig = httpRequestConfigSchema.parse({}),
   name = 'HTTP Request',
   previous?: TaskDefinitionBase,
 ): ManagedTaskDefinitionOf<HttpRequestExecutor> {
-  const inputs: InputPort[] = [{ handle: 'url', jsonSchema: { type: 'string' }, nullable: false }]
-  for (const group of ['query', 'headers'] as const) {
-    if (config[group].mode == 'object') inputs.push({ handle: group, jsonSchema: group == 'query' ? httpQuerySchema : httpHeaderSchema, nullable: true })
-    else
-      for (const parameterName of config[group].names.filter((value) => value.trim()))
-        inputs.push({
-          handle: `${group == 'query' ? 'query' : 'header'}.${parameterName}`,
-          jsonSchema: group == 'query' ? queryValueSchema : { type: 'string' },
-          nullable: true,
-        })
-  }
+  const inputs: InputPort[] = [
+    { handle: 'url', jsonSchema: { type: 'string' }, nullable: false },
+    ...requestParameterPorts(config, httpQuerySchema, queryValueSchema, httpHeaderSchema),
+  ]
   if (config.bodyFormat != 'none')
     inputs.push({
       handle: 'body',
@@ -82,8 +68,8 @@ export function httpRequestTask(
   return {
     name,
     executor: { ...config, kind: 'http-request' },
-    inputs: retain(inputs, previous?.inputs ?? []),
-    outputs: retain(outputs, previous?.outputs ?? []),
+    inputs: retainRequestPorts(inputs, previous?.inputs),
+    outputs: retainRequestPorts(outputs, previous?.outputs),
   }
 }
 export interface HttpRequestIssue {
@@ -96,18 +82,7 @@ export function httpRequestIssues(config: HttpRequestConfig): HttpRequestIssue[]
   const issues: HttpRequestIssue[] = []
   if (['GET', 'HEAD'].includes(config.method) && config.bodyFormat != 'none')
     issues.push({ field: 'bodyFormat', code: 'bodyUnsupported', message: 'GET and HEAD do not support a request body.' })
-  for (const group of ['query', 'headers'] as const) {
-    if (config[group].mode != 'fields') continue
-    const seen = new Set<string>()
-    for (const [index, name] of config[group].names.entries()) {
-      const key = group == 'headers' ? name.toLowerCase() : name
-      if (!name.trim() || seen.has(key))
-        issues.push({ field: group, index, code: 'parameterNamesInvalid', message: 'Parameter names must be nonempty and unique.' })
-      seen.add(key)
-      if (group == 'headers' && httpHeaderNameIssue(name, []) === 'invalid')
-        issues.push({ field: group, index, code: 'headerNameInvalid', message: 'Invalid HTTP header name.' })
-    }
-  }
+  issues.push(...requestParameterIssues(config))
   const auth = config.authentication
   if (auth.type != 'none') {
     const group = auth.type == 'apiKey' && auth.in == 'query' ? 'query' : 'headers'
@@ -218,49 +193,24 @@ export function parseHttpResponse(config: HttpRequestConfig, status: number, hea
 }
 
 /** Only a named parameter rename carries a value; changing source modes is not a rename. */
-export function httpRequestInputs(
-  mappings: Readonly<Record<string, InputMapping>>,
-  previous: TaskDefinitionBase,
-  next: TaskDefinitionBase,
-): Record<string, InputMapping> {
-  const candidate = renamedPort(previous.inputs, next.inputs)
-  const rename = candidate != null && ['query.', 'header.'].some((prefix) => candidate.every((name) => name.startsWith(prefix))) ? candidate : undefined
-  return remapInputMappings(mappings, next.inputs, rename)
-}
+export const httpRequestInputs = requestInputMappings
 
-/** A Task node as HTTP helpers read it; inline Tasks have no executor. */
-interface HttpTaskNode {
-  readonly inputs: Readonly<Record<string, InputMapping>>
-  readonly task: TaskDefinitionBase & { readonly executor?: TaskExecutor }
-}
-
-function httpRequestExecutor(node: HttpTaskNode): HttpRequestExecutor | undefined {
+function httpRequestExecutor(node: RequestTaskNode): HttpRequestExecutor | undefined {
   const executor = node.task.executor
   return executor?.kind === 'http-request' ? (executor as HttpRequestExecutor) : undefined
 }
 
 /** The object editor assembles named inputs without changing unrelated request settings. */
-export function withHttpParameterFields<Node extends HttpTaskNode>(node: Node, group: 'query' | 'headers', values: Record<string, JsonValue>): Node {
+export function withHttpParameterFields<Node extends RequestTaskNode>(node: Node, group: 'query' | 'headers', values: Record<string, JsonValue>): Node {
   const config = httpRequestExecutor(node)
   if (config == null) return node
-  const task = httpRequestTask({ ...config, [group]: { mode: 'fields', names: Object.keys(values) } }, node.task.name, node.task)
-  const inputs = httpRequestInputs(node.inputs, node.task, task)
-  const rename = renamedPort(node.task.inputs, task.inputs)
-  for (const [name, value] of Object.entries(values)) {
-    const handle = `${group === 'query' ? 'query' : 'header'}.${name}`
-    const existing = config[group].mode === 'fields' && (config[group].names.includes(name) || rename?.[1] === handle)
-    if (inputs[handle] == null && !existing) inputs[handle] = { kind: 'value', value }
-  }
-  // Only the HTTP Task and its input mappings change, so the node keeps its own type.
-  return { ...node, task, inputs } as Node
+  return withRequestParameterFields(node, group, values, config[group], (parameters) =>
+    httpRequestTask({ ...config, [group]: parameters }, node.task.name, node.task),
+  )
 }
 
-export function withHttpParameterSource<Node extends HttpTaskNode>(node: Node, group: 'query' | 'headers', mapping?: InputMapping): Node {
+export function withHttpParameterSource<Node extends RequestTaskNode>(node: Node, group: 'query' | 'headers', mapping?: InputMapping): Node {
   const config = httpRequestExecutor(node)
   if (config == null) return node
-  const task = httpRequestTask({ ...config, [group]: { mode: 'object', names: [] } }, node.task.name, node.task)
-  const inputs = httpRequestInputs(node.inputs, node.task, task)
-  if (mapping == null) delete inputs[group]
-  else inputs[group] = mapping
-  return { ...node, task, inputs } as Node
+  return withRequestParameterSource(node, group, mapping, (parameters) => httpRequestTask({ ...config, [group]: parameters }, node.task.name, node.task))
 }

package/src/runtime/common/engineContract.ts

@@ -10,10 +10,11 @@ export interface EngineContract {
   /** Code may call `context.fetch` for hosts declared by its `http` Capability. */
   readonly codeFetch?: boolean
   readonly flowState?: boolean
+  readonly connectorProxy?: boolean
 }
 
-/** v10 adds persistent Flow State to the published v9 Node compatibility and fetch contract. */
-export const currentEngineContract = 'open-flow-engine/v10'
+/** v11 adds Provider API requests through Connector Proxy. */
+export const currentEngineContract = 'open-flow-engine/v11'
 /** The published v8 Node compatibility contract, retained for existing Publications and Runs. */
 export const nodejsEngineContract = 'open-flow-engine/v8/nodejs-compat-v1'
 
@@ -65,10 +66,12 @@ const nodejsContract: EngineContract = {
 }
 
 const v9Contract: EngineContract = { ...nodejsContract, codeFetch: true, platformSource: platformSource('open-flow-engine/v9') }
-const currentContract: EngineContract = { ...v9Contract, flowState: true, platformSource: platformSource(currentEngineContract) }
+const v10Contract: EngineContract = { ...v9Contract, flowState: true, platformSource: platformSource('open-flow-engine/v10') }
+const currentContract: EngineContract = { ...v10Contract, connectorProxy: true, platformSource: platformSource(currentEngineContract) }
 
 export function findEngineContract(contract: string): EngineContract | undefined {
   if (contract == currentEngineContract) return currentContract
+  if (contract == 'open-flow-engine/v10') return v10Contract
   if (contract == 'open-flow-engine/v9') return v9Contract
   if (contract == 'open-flow-engine/v8') return v8Contract
   if (contract == nodejsEngineContract) return nodejsContract