@oomol-lab/open-flow 0.1.0-beta.74 → 0.1.0-beta.76

package/src/event-source/common/definition.ts

@@ -1,4 +1,4 @@
-import type { JsonValue } from '../../flow/common/change.ts'
+import type { JsonValue } from '../../types/index.ts'
 
 export interface SourceConfiguration {
   readonly identity: string

package/src/event-source/common/index.ts

@@ -1,9 +1,9 @@
 import type { EventSourceDefinition, SourceConfiguration } from './definition.ts'
 
 import { z } from 'zod'
-import { eventSourceViewSchema } from '../../control/common/eventSources.ts'
 import catalog from './catalog.generated.json' with { type: 'json' }
 import { SourceIdentityError } from './definition.ts'
+import { eventSourceViewSchema } from './view.ts'
 
 export type {
   EventSourceDefinition,

package/src/event-source/common/view.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+
+const id = z.string().min(1).max(256)
+
+/** Public projection of a source that Connector validates and Open Flow exposes unchanged. */
+export const eventSourceViewSchema = z.object({
+  appId: id.nullable(),
+  workspaceId: id.optional(),
+  installationId: id.optional(),
+  organizationId: id.optional(),
+  projectId: id.optional(),
+  projectKey: id.optional(),
+  subscriptionStatus: z.enum(['idle', 'pending', 'ready', 'error']).optional(),
+  lastError: z.string().optional(),
+  signingSecretConfigured: z.boolean().optional(),
+  manageSubscriptions: z.boolean().nullable(),
+  verificationTokenConfigured: z.boolean().nullable(),
+  encryptKeyConfigured: z.boolean().nullable(),
+  verifiedAt: z.string().nullable(),
+})

package/src/execution/common/checkpoint.ts

@@ -1,7 +1,7 @@
 import type { Graph, JsonValue } from '../../flow/common/change.ts'
+import type { AgentCheckpoint } from '../../runtime/common/runtime.ts'
 import type { DependenciesCheckpoint } from './dependencies.ts'
 import type { ExecutableNode } from './node-execution.ts'
-import type { AgentCheckpoint } from './runtime.ts'
 
 import { z } from 'zod'
 import { isTriggerNode } from '../../flow/common/change.ts'

package/src/execution/common/events.ts

@@ -22,6 +22,7 @@ const nodeKinds = new Set([
   'decision',
   'javascript',
   'openapi',
+  'http-request',
   'llm',
   'value',
   'wait',
@@ -54,6 +55,7 @@ function nodeKind(
   | 'decision'
   | 'javascript'
   | 'openapi'
+  | 'http-request'
   | 'llm'
   | 'value'
   | 'wait'
@@ -73,6 +75,7 @@ function nodeKind(
     | 'decision'
     | 'javascript'
     | 'openapi'
+    | 'http-request'
     | 'llm'
     | 'value'
     | 'wait'

package/src/execution/common/node-execution.ts

@@ -1,9 +1,9 @@
 import type { AgentConfig } from '../../flow/common/agent.ts'
 import type { Graph, GraphNode, InputMapping, InputPortDefinition, JsonValue, TriggerNode } from '../../flow/common/change.ts'
 import type { WebhookResponseSnapshot } from '../../flow/common/webhookResponse.ts'
+import type { AgentCheckpoint, AgentResult } from '../../runtime/common/runtime.ts'
 import type { FlowRunCheckpoint } from './checkpoint.ts'
 import type { Dependencies } from './dependencies.ts'
-import type { AgentCheckpoint, AgentResult } from './runtime.ts'
 import type { FlowRunOptions, SchedulerEvent, SchedulerFailure, TaskInvocation } from './scheduler.ts'
 
 import * as Effect from 'effect/Effect'
@@ -108,6 +108,7 @@ function nodeKind(
   | 'decision'
   | 'javascript'
   | 'openapi'
+  | 'http-request'
   | 'llm'
   | 'value'
   | 'wait'
@@ -319,7 +320,8 @@ export function executeNode(
     const title = nodeTitle(node)
     const projectedInputs = Object.fromEntries(
       Object.entries(nodeInputs).filter(([handle]) => {
-        if (node.kind == 'task' && 'executor' in node.task && node.task?.executor.kind == 'openapi' && handle.startsWith('auth.')) return false
+        if (node.kind == 'task' && 'executor' in node.task && ['openapi', 'http-request'].includes(node.task.executor.kind) && handle.startsWith('auth.'))
+          return false
         const mapping = nodeInputMappings(node)[handle]
         return mapping?.kind != 'sources' || mapping.sources.every((source) => source.kind != 'binding')
       }),
@@ -365,7 +367,7 @@ export function executeNode(
             Object.entries(nodeInputs).filter(([handle]) => {
               if (additional.has(handle)) return false
               const task = 'executor' in node.task ? node.task : undefined
-              if (task?.executor.kind != 'openapi') return true
+              if (task == null || !['openapi', 'http-request'].includes(task.executor.kind)) return true
               const mapping = node.inputs[handle]
               return (
                 mapping?.kind != 'unset' &&

package/src/execution/common/scheduler.ts

@@ -2,10 +2,10 @@ import type { TaskCapability, Graph, JsonValue, WaitAction, WaitAutoContinue } f
 import type { NodeErrorData } from '../../flow/common/errorHandling.ts'
 import type { PreparedFlow } from '../../flow/common/semantics.ts'
 import type { WebhookResponseSnapshot } from '../../flow/common/webhookResponse.ts'
+import type { AgentCheckpoint } from '../../runtime/common/runtime.ts'
 import type { PreviousNode } from '../../types/index.ts'
 import type { FlowRunCheckpoint } from './checkpoint.ts'
 import type { ExecutableNode, NodeResult } from './node-execution.ts'
-import type { AgentCheckpoint } from './runtime.ts'
 
 import * as Cause from 'effect/Cause'
 import * as Clock from 'effect/Clock'
@@ -69,6 +69,7 @@ export type SchedulerEvent =
         | 'decision'
         | 'javascript'
         | 'openapi'
+        | 'http-request'
         | 'llm'
         | 'value'
         | 'wait'

package/src/flow/common/change.ts

@@ -1,12 +1,27 @@
-import type { JsonValue, Port, PortDefinition } from '../../types/index.ts'
+import type { TriggerNode, TriggerSchedule } from '../../trigger/common/model.ts'
+import type {
+  CodeModule,
+  ConnectorCapability,
+  FixedInputValue,
+  GraphNodeBase,
+  InlineTaskDefinition,
+  InputMapping,
+  InputPort,
+  JsonValue,
+  ManagedTaskDefinitionOf,
+  RetryConfiguration,
+  Port,
+  Source,
+  TaskCapability,
+  WorkflowCapability,
+  WorkflowExecutor,
+} from './model.ts'
 
-import { assertOpenApiAuthBindings } from '../../openapi/common/authBindings.ts'
 export { fixedInputValue, inputValue, inputValues } from './inputValue.ts'
-import type { RetryConfiguration } from './retry.ts'
 import type { WebhookMethod } from './webhookMethod.ts'
 
 import { dequal } from 'dequal/lite'
-import { authoringDefinitionSchemas, currentFlowModelVersion, decodeRevisionContent } from './changeSchema.ts'
+import { assertDocumentHttpAuthBindings, authoringDefinitionSchemas, currentFlowModelVersion, decodeRevisionContent } from './changeSchema.ts'
 import { nodeInputMappings, setConditionInput } from './condition.ts'
 import { supportsNodeErrorHandling } from './errorHandling.ts'
 import { supportsNodeRetry } from './retry.ts'
@@ -18,7 +33,39 @@ export { nodeSystemOutputPorts, supportsNodeErrorHandling, nodeErrorSchema } fro
 export type { NodeErrorData } from './errorHandling.ts'
 export type { WebhookMethod }
 
-export type { JsonValue, Port, PortDefinition } from '../../types/index.ts'
+export type {
+  BindingSource,
+  CodeModule,
+  ConnectorAccessCapability,
+  ConnectorActionCapability,
+  ConnectorCapability,
+  ConnectorPermissionCapability,
+  FixedInputValue,
+  Group,
+  InlineTaskDefinition,
+  InputMapping,
+  InputPort,
+  InputPortDefinition,
+  InputValues,
+  JsonValue,
+  NodeSource,
+  Port,
+  PortDefinition,
+  Source,
+  TaskCapability,
+  WorkflowCapability,
+} from './model.ts'
+export { portsByHandle } from './model.ts'
+export type {
+  IntegrationBodyFormat,
+  IntegrationEndpointDeclaration,
+  IntegrationEndpointMethod,
+  TriggerKeySnapshot,
+  TriggerNode,
+  TriggerSchedule,
+  WebhookBodyField,
+  WebhookOptions,
+} from '../../trigger/common/model.ts'
 
 export { isSchemaKeyword } from './schemaKeywords.ts'
 export type { SchemaKeyword, SchemaMismatch } from './schemaKeywords.ts'
@@ -42,52 +89,6 @@ export function validVariableName(value: string): boolean {
   return value.length <= 256 && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) && value.slice(0, 3).toUpperCase() != 'OO_'
 }
 
-export interface InputPortDefinition extends PortDefinition {
-  readonly value?: JsonValue
-}
-
-export interface InputPort extends InputPortDefinition {
-  readonly handle: string
-}
-
-export interface Group {
-  readonly collapsed?: boolean
-  readonly group: string
-}
-
-export function portsByHandle<Value extends Port>(ports: readonly (Value | Group)[]): Readonly<Record<string, Value>> {
-  return Object.fromEntries(ports.flatMap((port) => ('handle' in port ? [[port.handle, port]] : [])))
-}
-
-export interface NodeSource {
-  readonly system?: true
-  readonly field?: string
-  readonly kind: 'node'
-  readonly nodeId: string
-  readonly output: string
-}
-
-export interface BindingSource {
-  readonly bindingId: string
-  readonly kind: 'binding'
-}
-
-export type FixedInputValue = { readonly kind: 'unset' } | { readonly kind: 'value'; readonly value: JsonValue }
-export type InputValues = Readonly<Record<string, FixedInputValue>>
-
-export type InputMapping = FixedInputValue | { readonly kind: 'sources'; readonly sources: readonly (BindingSource | NodeSource)[] }
-
-interface GraphNodeBase {
-  readonly description?: string
-  readonly icon?: string
-  readonly inputs: Readonly<Record<string, InputMapping>>
-  readonly name?: string
-  readonly maxExecutions?: number
-  readonly timeoutMs?: number
-  readonly retry?: RetryConfiguration
-  readonly onError?: 'stop' | 'error'
-}
-
 export interface ValueNode extends GraphNodeBase {
   readonly kind: 'value'
   readonly values: readonly InputPort[]
@@ -138,8 +139,6 @@ export type ConditionOperator =
   | 'notHasValue'
   | 'startsWith'
 
-export type Source = BindingSource | NodeSource
-
 export type ConditionOperand =
   | { readonly kind: 'value'; readonly value?: JsonValue; readonly jsonSchema?: JsonValue }
   | { readonly kind: 'source'; readonly source: Source }
@@ -167,7 +166,8 @@ export interface ConditionNode extends GraphNodeBase {
 }
 
 export type ManagedTaskExecutor =
-  | import('../../workflow/common/workflow.ts').WorkflowExecutor
+  | import('../../http/common/httpRequest.ts').HttpRequestExecutor
+  | WorkflowExecutor
   | import('../../decision/common/decision.ts').DecisionExecutor
   | import('../../openapi/common/openapi.ts').OpenApiExecutor
   | { readonly kind: 'connector'; readonly action: string; readonly connectionId?: string; readonly outputMode?: 'value' }
@@ -204,23 +204,12 @@ export interface AgentConnectorTool extends AgentToolBase {
   readonly connectionId?: string
 }
 
-export interface WorkflowCapability {
-  readonly kind: 'workflow'
-  readonly name: string
-  readonly flowId: string
-  readonly revisionId: string
-  readonly inputs: readonly Port[]
-  readonly outputs: readonly Port[] | null
-}
-
 export interface AgentWorkflowTool extends AgentToolBase, Omit<WorkflowCapability, 'inputs'> {
   readonly action?: never
   readonly connectionId?: never
 }
 
 export type AgentTool = AgentConnectorTool | AgentWorkflowTool
-export type TaskCapability = ConnectorCapability | WorkflowCapability
-
 export const workflowToolNamePattern = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/
 
 export function workflowToolNameIssue(name: string, otherNames: Iterable<string> = []): 'invalid' | 'duplicate' | undefined {
@@ -238,33 +227,13 @@ export function decodeTaskCapabilities(value: unknown): readonly TaskCapability[
     if (workflowToolNameIssue(item.name, names)) throw new TypeError('Workflow tool names must be unique provider-compatible names.')
     names.add(item.name)
   }
+  const http = parsed.filter((item) => item.kind == 'http')
+  if (http.length > 1 || http.some((item) => new Set(item.hosts).size != item.hosts.length))
+    throw new TypeError('Code declares HTTP hosts once, without duplicates.')
   let connectorIndex = 0
   return parsed.map((item) => (item.kind == 'connector' ? connectors[connectorIndex++]! : item)) as readonly TaskCapability[]
 }
 
-export interface ConnectorAccessCapability {
-  readonly actionHints?: readonly string[]
-  readonly connectionHints?: readonly {
-    readonly action: string
-    readonly connectionId: string
-    readonly alias?: string
-  }[]
-  readonly kind: 'connector'
-}
-
-export interface ConnectorActionCapability {
-  readonly action: string
-  readonly connections: readonly { readonly connectionId: string; readonly alias?: string }[]
-  readonly connectionId?: string
-  readonly kind: 'connector'
-}
-
-export type ConnectorPermissionCapability =
-  | { readonly kind: 'connector'; readonly mode: 'shared' }
-  | { readonly kind: 'connector'; readonly mode: 'independent'; readonly actions: readonly { readonly action: string; readonly connectionId?: string }[] }
-
-export type ConnectorCapability = ConnectorAccessCapability | ConnectorActionCapability | ConnectorPermissionCapability
-
 export function decodeConnectorCapabilities(value: unknown): readonly ConnectorCapability[] {
   if (!Array.isArray(value)) throw new TypeError('Connector capabilities must be an array.')
   if (value.length == 0) return []
@@ -388,20 +357,7 @@ export function decodeConnectorCapabilities(value: unknown): readonly ConnectorC
   })
 }
 
-interface TaskDefinitionBase {
-  readonly inputs: readonly (InputPort | Group)[]
-  readonly name: string
-  readonly outputs: readonly (Port | Group)[]
-}
-
-export interface InlineTaskDefinition extends TaskDefinitionBase {
-  readonly capabilities?: readonly TaskCapability[]
-  readonly moduleId: string
-}
-
-export interface ManagedTaskDefinition extends TaskDefinitionBase {
-  readonly executor: ManagedTaskExecutor
-}
+export type ManagedTaskDefinition = ManagedTaskDefinitionOf<ManagedTaskExecutor>
 
 export type TaskDefinition = InlineTaskDefinition | ManagedTaskDefinition
 
@@ -416,89 +372,6 @@ export interface Graph {
   readonly nodes: Readonly<Record<string, GraphNode>>
 }
 
-export type TriggerSchedule =
-  | { readonly expression: string; readonly timezone: string; readonly type: 'cron' }
-  | { readonly type: 'every'; readonly unit: 'day' | 'hour' | 'minute' | 'month' | 'week'; readonly value: number }
-
-interface TriggerKeySnapshotBase {
-  readonly configInputs: readonly (InputPort | Group)[]
-  readonly definitionVersion: number
-  readonly description: string
-  readonly displayName: string
-  readonly key: string
-  readonly name: string
-  readonly outputs: readonly Port[]
-  readonly provider: string
-}
-
-export type IntegrationEndpointMethod = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT'
-
-export type IntegrationBodyFormat = 'form' | 'json' | 'multipart' | 'text'
-
-export interface IntegrationEndpointDeclaration {
-  readonly body: {
-    readonly allowArray: boolean
-    readonly allowEmpty: boolean
-    readonly formats: readonly IntegrationBodyFormat[]
-  }
-  readonly methods: readonly IntegrationEndpointMethod[]
-  readonly successStatus: number
-}
-
-export type TriggerKeySnapshot =
-  | (TriggerKeySnapshotBase & { readonly type: 'poll' })
-  | (TriggerKeySnapshotBase & { readonly endpoint: IntegrationEndpointDeclaration; readonly type: 'integration' })
-
-export interface WebhookBodyField extends InputPort {}
-
-export interface WebhookOptions {
-  readonly allowedOrigins?: readonly string[]
-  readonly responseBody?:
-    | { readonly kind: 'workflow-outputs'; readonly output?: string; readonly timeoutMs?: number }
-    | { readonly kind: 'webhook-response'; readonly nodeId?: string; readonly timeoutMs?: number }
-  readonly responseData?: string
-  readonly responseHeaders?: Readonly<Record<string, string>>
-  readonly responseHeadersSource?: {
-    readonly kind: 'workflow-outputs'
-    readonly output?: string
-  }
-  readonly responseHeaderOutputs?: Readonly<Record<string, string>>
-  readonly responseStatusCode?: number
-  readonly responseStatusCodeOutput?: string
-}
-
-interface TriggerNodeBase {
-  readonly onError?: never
-  readonly description?: string
-  readonly icon?: string
-  readonly name: string
-}
-
-export type TriggerNode =
-  | (TriggerNodeBase & { readonly kind: 'manual' })
-  | (TriggerNodeBase & { readonly kind: 'start'; readonly inputDefs: readonly Port[] })
-  | (TriggerNodeBase & { readonly kind: 'error'; readonly sourceFlowIds?: readonly string[] })
-  | (TriggerNodeBase & {
-      readonly bodyFields: readonly WebhookBodyField[]
-      readonly kind: 'webhook'
-      readonly method: WebhookMethod
-      readonly options?: WebhookOptions
-    })
-  | (TriggerNodeBase & { readonly cronTimes: readonly TriggerSchedule[]; readonly kind: 'cron' })
-  | (TriggerNodeBase & {
-      readonly connectionId?: string
-      readonly config: InputValues
-      readonly definition: TriggerKeySnapshot & { readonly type: 'poll' }
-      readonly kind: 'poll'
-      readonly pollTimes: readonly TriggerSchedule[]
-    })
-  | (TriggerNodeBase & {
-      readonly connectionId?: string
-      readonly config: InputValues
-      readonly definition: TriggerKeySnapshot & { readonly type: 'integration' }
-      readonly kind: 'integration'
-    })
-
 export interface OutputsNode extends Omit<GraphNodeBase, 'inputs'> {
   readonly kind: 'outputs'
   readonly outputDefs: readonly Port[]
@@ -522,12 +395,6 @@ export interface FlowDocument {
   readonly graph: Graph
 }
 
-export interface CodeModule {
-  readonly imports: readonly string[]
-  readonly name: string
-  readonly source: string
-}
-
 export interface RevisionContent {
   readonly document: FlowDocument
   readonly modelVersion: 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | typeof currentFlowModelVersion
@@ -1031,6 +898,6 @@ export function applyFlowChanges(content: RevisionContent, operations: readonly
       }
     }
   }
-  assertOpenApiAuthBindings(document)
+  assertDocumentHttpAuthBindings(document)
   return upgradeDecodedRevisionContent({ document, modelVersion: currentFlowModelVersion, modules })
 }

package/src/flow/common/changeSchema.ts

@@ -3,7 +3,9 @@ import type { ChangeOperation, FlowDocument, JsonValue, RevisionContent } from '
 import { dequal } from 'dequal/lite'
 import { z } from 'zod'
 import { limitDecisionTask } from '../../decision/common/decision.ts'
-import { assertOpenApiAuthBindings } from '../../openapi/common/authBindings.ts'
+import { assertHttpAuthBindings } from '../../http/common/authBindings.ts'
+import { isHttpHost, maxHttpHosts } from '../../http/common/hosts.ts'
+import { httpRequestExecutorSchema } from '../../http/common/httpRequest.ts'
 import { checkJsonDepth } from './json.ts'
 import { retryConfigurationSchema } from './retry.ts'
 import { triggerScheduleSchema } from './triggerScheduleSchema.ts'
@@ -11,7 +13,7 @@ import { waitAutoContinueDraftSchema, waitAutoContinueSchema } from './wait.ts'
 import { webhookMethods } from './webhookMethod.ts'
 import { webhookResponseTimeout } from './webhookResponse.ts'
 
-export const currentFlowModelVersion = 11
+export const currentFlowModelVersion = 12
 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.',
@@ -56,7 +58,15 @@ export const workflowCapabilitySchema = z.strictObject({
   inputs: z.array(port),
   outputs: z.array(port).nullable(),
 })
-const capability = z.union([connectorCapabilitySchema, workflowCapabilitySchema])
+export const httpCapabilitySchema = z.strictObject({
+  kind: z.literal('http'),
+  hosts: z
+    .array(text.refine(isHttpHost, 'Use a lowercase host name or IPv4 address, optionally prefixed by "*." for subdomains.'))
+    .min(1)
+    .max(maxHttpHosts)
+    .describe('Hosts Code may call with context.fetch. "*.example.com" matches subdomains only.'),
+})
+const capability = z.union([connectorCapabilitySchema, workflowCapabilitySchema, httpCapabilitySchema])
 const inline = z.object({ ...ports, name: text, moduleId: text, capabilities: z.array(capability).optional() })
 const agentValue = z.union([z.object({ kind: z.literal('value'), value: json }), z.object({ kind: z.literal('input'), input: text })])
 const agentInput = z.union([agentValue, z.object({ kind: z.literal('model') })])
@@ -118,6 +128,7 @@ const managedFields = z.object({
         .optional(),
     }),
     z.strictObject({ kind: z.literal('workflow'), flowId: text, revisionId: text }),
+    httpRequestExecutorSchema,
   ]),
 })
 
@@ -306,6 +317,7 @@ const revision = z.object({
     z.literal(8),
     z.literal(9),
     z.literal(10),
+    z.literal(11),
     z.literal(currentFlowModelVersion),
   ]),
   document,
@@ -591,7 +603,7 @@ export function decodeRevisionContent(value: unknown): RevisionContent {
   checkJsonDepth(value)
   const content = revision.parse(value) as RevisionContent
   checkModelVersion(content)
-  assertOpenApiAuthBindings(content.document)
+  assertDocumentHttpAuthBindings(content.document)
   return content
 }
 
@@ -601,7 +613,7 @@ export function decodeRevisionEnvelope(value: unknown): RevisionContent {
   const candidate = revisionSource.modelVersion == 2 ? { ...revisionSource, document: upgradeLegacyDocument(revisionSource.document) } : value
   const content = envelope.parse(candidate) as RevisionContent
   checkModelVersion(content)
-  assertOpenApiAuthBindings(content.document)
+  assertDocumentHttpAuthBindings(content.document)
   return { modelVersion: content.modelVersion, document: content.document, modules: content.modules }
 }
 
@@ -711,6 +723,21 @@ export function changeOperationsSchema(kind?: string): JsonValue {
 }
 
 function checkModelVersion(content: RevisionContent): void {
+  if (
+    content.modelVersion < 12 &&
+    Object.values(content.document.graph.nodes).some(
+      (candidateNode) =>
+        candidateNode.kind == 'task' && 'moduleId' in candidateNode.task && candidateNode.task.capabilities?.some((item) => item.kind == 'http'),
+    )
+  )
+    throw new TypeError('Code HTTP access requires Flow model version 12.')
+  if (
+    content.modelVersion < 11 &&
+    Object.values(content.document.graph.nodes).some(
+      (candidateNode) => candidateNode.kind == 'task' && 'executor' in candidateNode.task && candidateNode.task.executor.kind == 'http-request',
+    )
+  )
+    throw new TypeError('HTTP Request requires Flow model version 11.')
   if (
     content.modelVersion < 11 &&
     Object.values(content.document.graph.nodes).some(
@@ -781,3 +808,10 @@ function checkModelVersion(content: RevisionContent): void {
   if (content.modelVersion < 5 && Object.values(content.document.graph.nodes).some((itemNode) => itemNode.kind == 'error'))
     throw new TypeError('Error workflows require Flow model version 5.')
 }
+
+export function assertDocumentHttpAuthBindings(content: FlowDocument): void {
+  for (const graphNode of Object.values(content.graph.nodes)) {
+    if (graphNode.kind == 'task' && 'executor' in graphNode.task && ['openapi', 'http-request'].includes(graphNode.task.executor.kind))
+      assertHttpAuthBindings(graphNode.inputs)
+  }
+}

package/src/flow/common/connectionUsage.ts

@@ -93,7 +93,7 @@ export function clearNodeConnections(graph: FlowDocument['graph'], connectionId?
           return [id, node]
         }
         const capabilities = node.task.capabilities?.map((capability) => {
-          if (capability.kind == 'workflow') return capability
+          if (capability.kind == 'workflow' || capability.kind == 'http') return capability
           if (!('mode' in capability)) {
             if ('action' in capability) {
               const { connectionId: selected, ...rest } = capability

package/src/flow/common/graph.ts

@@ -1,3 +1,4 @@
+import type { InputPort } from './change.ts'
 import type {
   BindingSource,
   FlowDocument,
@@ -14,6 +15,7 @@ import type {
 } from './change.ts'
 import type { Diagnostic } from './semantics.ts'
 
+import { httpHeaderNameIssue } from '../../http/common/headers.ts'
 import { missingTriggerConfig, resolveTriggerConfig } from '../../trigger/common/config.ts'
 import { triggerOutputDefinitions, triggerOutputPorts, webhookSupportsBody } from '../../trigger/common/contract.ts'
 import { isTriggerNode, portsByHandle, validVariableName } from './change.ts'
@@ -27,7 +29,6 @@ import {
   webhookResponseInputs,
   validWebhookStatus,
   webhookHeaderValues,
-  webhookHeaderNameIssue,
   webhookHeaderValuePort,
   webhookHeadersPort,
   webhookResponseAllowsBody,
@@ -92,7 +93,7 @@ export function webhookResponseDiagnostics(graph: Graph, triggerId: string, path
     ] as const) {
       const names: string[] = []
       for (const name of Object.keys(headers ?? {})) {
-        if (webhookHeaderNameIssue(name, names) != null)
+        if (httpHeaderNameIssue(name, names) != null)
           diagnostics.push(graphDiagnostic('trigger.webhook-response-header-name', 'Use valid, unique HTTP header names.', location))
         names.push(name)
       }
@@ -615,9 +616,14 @@ export function checkInputSources(
 }
 
 /** Enumerate structurally available outputs while retaining their compatibility with one input. */
-export function inputSourceCandidates(graph: Graph, target: string, handle: string): Readonly<Record<string, readonly InputSourceCandidate[]>> {
+export function inputSourceCandidates(
+  graph: Graph,
+  target: string,
+  handle: string,
+  inputPort?: InputPort,
+): Readonly<Record<string, readonly InputSourceCandidate[]>> {
   const targetNode = graph.nodes[target]
-  const input = targetNode == null ? undefined : nodeInputPorts(targetNode)[handle]
+  const input = inputPort ?? (targetNode == null ? undefined : nodeInputPorts(targetNode)[handle])
   if (input == null) return {}
   const analysis = graphPaths(graph)
   return Object.fromEntries(

package/src/flow/common/inputValue.ts

@@ -1,4 +1,4 @@
-import type { FixedInputValue, InputValues, InputMapping, JsonValue } from './change.ts'
+import type { FixedInputValue, InputValues, InputMapping, JsonValue } from './model.ts'
 
 /** An explicit clear suppresses the default; absent mappings still inherit it. */
 export function inputValue(mapping: InputMapping | undefined, fallback: JsonValue | undefined): JsonValue | undefined {