@aws-sdk/client-bedrock-agentcore 3.1033.0 → 3.1035.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -13,10 +13,16 @@ import {
   DescriptorType,
   EventFilterCondition,
   ExtractionJobStatus,
+  HarnessConversationRole,
+  HarnessStopReason,
+  HarnessToolType,
+  HarnessToolUseStatus,
+  HarnessToolUseType,
   LanguageRuntime,
   MemoryRecordStatus,
   MouseButton,
   Oauth2FlowType,
+  OAuthGrantType,
   OperatorType,
   ProgrammingLanguage,
   RegistryRecordStatus,
@@ -1260,6 +1266,701 @@ export interface InvokeCodeInterpreterResponse {
   sessionId?: string | undefined;
   stream: AsyncIterable<CodeInterpreterStreamOutput> | undefined;
 }
+export interface HarnessReasoningTextBlock {
+  text: string | undefined;
+  signature?: string | undefined;
+}
+export type HarnessReasoningContentBlock =
+  | HarnessReasoningContentBlock.ReasoningTextMember
+  | HarnessReasoningContentBlock.RedactedContentMember
+  | HarnessReasoningContentBlock.$UnknownMember;
+export declare namespace HarnessReasoningContentBlock {
+  interface ReasoningTextMember {
+    reasoningText: HarnessReasoningTextBlock;
+    redactedContent?: never;
+    $unknown?: never;
+  }
+  interface RedactedContentMember {
+    reasoningText?: never;
+    redactedContent: Uint8Array;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    reasoningText?: never;
+    redactedContent?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    reasoningText: (value: HarnessReasoningTextBlock) => T;
+    redactedContent: (value: Uint8Array) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export type HarnessToolResultContentBlock =
+  | HarnessToolResultContentBlock.JsonMember
+  | HarnessToolResultContentBlock.TextMember
+  | HarnessToolResultContentBlock.$UnknownMember;
+export declare namespace HarnessToolResultContentBlock {
+  interface TextMember {
+    text: string;
+    json?: never;
+    $unknown?: never;
+  }
+  interface JsonMember {
+    text?: never;
+    json: __DocumentType;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    json?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    json: (value: __DocumentType) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export interface HarnessToolResultBlock {
+  toolUseId: string | undefined;
+  content: HarnessToolResultContentBlock[] | undefined;
+  status?: HarnessToolUseStatus | undefined;
+  type?: HarnessToolUseType | undefined;
+}
+export interface HarnessToolUseBlock {
+  name: string | undefined;
+  toolUseId: string | undefined;
+  input: __DocumentType | undefined;
+  type?: HarnessToolUseType | undefined;
+  serverName?: string | undefined;
+}
+export type HarnessContentBlock =
+  | HarnessContentBlock.ReasoningContentMember
+  | HarnessContentBlock.TextMember
+  | HarnessContentBlock.ToolResultMember
+  | HarnessContentBlock.ToolUseMember
+  | HarnessContentBlock.$UnknownMember;
+export declare namespace HarnessContentBlock {
+  interface TextMember {
+    text: string;
+    toolUse?: never;
+    toolResult?: never;
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface ToolUseMember {
+    text?: never;
+    toolUse: HarnessToolUseBlock;
+    toolResult?: never;
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface ToolResultMember {
+    text?: never;
+    toolUse?: never;
+    toolResult: HarnessToolResultBlock;
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface ReasoningContentMember {
+    text?: never;
+    toolUse?: never;
+    toolResult?: never;
+    reasoningContent: HarnessReasoningContentBlock;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    toolUse?: never;
+    toolResult?: never;
+    reasoningContent?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    toolUse: (value: HarnessToolUseBlock) => T;
+    toolResult: (value: HarnessToolResultBlock) => T;
+    reasoningContent: (value: HarnessReasoningContentBlock) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export interface HarnessMessage {
+  role: HarnessConversationRole | undefined;
+  content: HarnessContentBlock[] | undefined;
+}
+export interface HarnessBedrockModelConfig {
+  modelId: string | undefined;
+  maxTokens?: number | undefined;
+  temperature?: number | undefined;
+  topP?: number | undefined;
+}
+export interface HarnessGeminiModelConfig {
+  modelId: string | undefined;
+  apiKeyArn: string | undefined;
+  maxTokens?: number | undefined;
+  temperature?: number | undefined;
+  topP?: number | undefined;
+  topK?: number | undefined;
+}
+export interface HarnessOpenAiModelConfig {
+  modelId: string | undefined;
+  apiKeyArn: string | undefined;
+  maxTokens?: number | undefined;
+  temperature?: number | undefined;
+  topP?: number | undefined;
+}
+export type HarnessModelConfiguration =
+  | HarnessModelConfiguration.BedrockModelConfigMember
+  | HarnessModelConfiguration.GeminiModelConfigMember
+  | HarnessModelConfiguration.OpenAiModelConfigMember
+  | HarnessModelConfiguration.$UnknownMember;
+export declare namespace HarnessModelConfiguration {
+  interface BedrockModelConfigMember {
+    bedrockModelConfig: HarnessBedrockModelConfig;
+    openAiModelConfig?: never;
+    geminiModelConfig?: never;
+    $unknown?: never;
+  }
+  interface OpenAiModelConfigMember {
+    bedrockModelConfig?: never;
+    openAiModelConfig: HarnessOpenAiModelConfig;
+    geminiModelConfig?: never;
+    $unknown?: never;
+  }
+  interface GeminiModelConfigMember {
+    bedrockModelConfig?: never;
+    openAiModelConfig?: never;
+    geminiModelConfig: HarnessGeminiModelConfig;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    bedrockModelConfig?: never;
+    openAiModelConfig?: never;
+    geminiModelConfig?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    bedrockModelConfig: (value: HarnessBedrockModelConfig) => T;
+    openAiModelConfig: (value: HarnessOpenAiModelConfig) => T;
+    geminiModelConfig: (value: HarnessGeminiModelConfig) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export type HarnessSkill =
+  | HarnessSkill.PathMember
+  | HarnessSkill.$UnknownMember;
+export declare namespace HarnessSkill {
+  interface PathMember {
+    path: string;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    path?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    path: (value: string) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export type HarnessSystemContentBlock =
+  | HarnessSystemContentBlock.TextMember
+  | HarnessSystemContentBlock.$UnknownMember;
+export declare namespace HarnessSystemContentBlock {
+  interface TextMember {
+    text: string;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export interface HarnessAgentCoreBrowserConfig {
+  browserArn?: string | undefined;
+}
+export interface HarnessAgentCoreCodeInterpreterConfig {
+  codeInterpreterArn?: string | undefined;
+}
+export interface Unit {}
+export interface OAuthCredentialProvider {
+  providerArn: string | undefined;
+  scopes: string[] | undefined;
+  customParameters?: Record<string, string> | undefined;
+  grantType?: OAuthGrantType | undefined;
+  defaultReturnUrl?: string | undefined;
+}
+export type HarnessGatewayOutboundAuth =
+  | HarnessGatewayOutboundAuth.AwsIamMember
+  | HarnessGatewayOutboundAuth.NoneMember
+  | HarnessGatewayOutboundAuth.OauthMember
+  | HarnessGatewayOutboundAuth.$UnknownMember;
+export declare namespace HarnessGatewayOutboundAuth {
+  interface AwsIamMember {
+    awsIam: Unit;
+    none?: never;
+    oauth?: never;
+    $unknown?: never;
+  }
+  interface NoneMember {
+    awsIam?: never;
+    none: Unit;
+    oauth?: never;
+    $unknown?: never;
+  }
+  interface OauthMember {
+    awsIam?: never;
+    none?: never;
+    oauth: OAuthCredentialProvider;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    awsIam?: never;
+    none?: never;
+    oauth?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    awsIam: (value: Unit) => T;
+    none: (value: Unit) => T;
+    oauth: (value: OAuthCredentialProvider) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export interface HarnessAgentCoreGatewayConfig {
+  gatewayArn: string | undefined;
+  outboundAuth?: HarnessGatewayOutboundAuth | undefined;
+}
+export interface HarnessInlineFunctionConfig {
+  description: string | undefined;
+  inputSchema: __DocumentType | undefined;
+}
+export interface HarnessRemoteMcpConfig {
+  url: string | undefined;
+  headers?: Record<string, string> | undefined;
+}
+export type HarnessToolConfiguration =
+  | HarnessToolConfiguration.AgentCoreBrowserMember
+  | HarnessToolConfiguration.AgentCoreCodeInterpreterMember
+  | HarnessToolConfiguration.AgentCoreGatewayMember
+  | HarnessToolConfiguration.InlineFunctionMember
+  | HarnessToolConfiguration.RemoteMcpMember
+  | HarnessToolConfiguration.$UnknownMember;
+export declare namespace HarnessToolConfiguration {
+  interface RemoteMcpMember {
+    remoteMcp: HarnessRemoteMcpConfig;
+    agentCoreBrowser?: never;
+    agentCoreGateway?: never;
+    inlineFunction?: never;
+    agentCoreCodeInterpreter?: never;
+    $unknown?: never;
+  }
+  interface AgentCoreBrowserMember {
+    remoteMcp?: never;
+    agentCoreBrowser: HarnessAgentCoreBrowserConfig;
+    agentCoreGateway?: never;
+    inlineFunction?: never;
+    agentCoreCodeInterpreter?: never;
+    $unknown?: never;
+  }
+  interface AgentCoreGatewayMember {
+    remoteMcp?: never;
+    agentCoreBrowser?: never;
+    agentCoreGateway: HarnessAgentCoreGatewayConfig;
+    inlineFunction?: never;
+    agentCoreCodeInterpreter?: never;
+    $unknown?: never;
+  }
+  interface InlineFunctionMember {
+    remoteMcp?: never;
+    agentCoreBrowser?: never;
+    agentCoreGateway?: never;
+    inlineFunction: HarnessInlineFunctionConfig;
+    agentCoreCodeInterpreter?: never;
+    $unknown?: never;
+  }
+  interface AgentCoreCodeInterpreterMember {
+    remoteMcp?: never;
+    agentCoreBrowser?: never;
+    agentCoreGateway?: never;
+    inlineFunction?: never;
+    agentCoreCodeInterpreter: HarnessAgentCoreCodeInterpreterConfig;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    remoteMcp?: never;
+    agentCoreBrowser?: never;
+    agentCoreGateway?: never;
+    inlineFunction?: never;
+    agentCoreCodeInterpreter?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    remoteMcp: (value: HarnessRemoteMcpConfig) => T;
+    agentCoreBrowser: (value: HarnessAgentCoreBrowserConfig) => T;
+    agentCoreGateway: (value: HarnessAgentCoreGatewayConfig) => T;
+    inlineFunction: (value: HarnessInlineFunctionConfig) => T;
+    agentCoreCodeInterpreter: (
+      value: HarnessAgentCoreCodeInterpreterConfig
+    ) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export interface HarnessTool {
+  type: HarnessToolType | undefined;
+  name?: string | undefined;
+  config?: HarnessToolConfiguration | undefined;
+}
+export interface InvokeHarnessRequest {
+  harnessArn: string | undefined;
+  runtimeSessionId: string | undefined;
+  messages: HarnessMessage[] | undefined;
+  model?: HarnessModelConfiguration | undefined;
+  systemPrompt?: HarnessSystemContentBlock[] | undefined;
+  tools?: HarnessTool[] | undefined;
+  skills?: HarnessSkill[] | undefined;
+  allowedTools?: string[] | undefined;
+  maxIterations?: number | undefined;
+  maxTokens?: number | undefined;
+  timeoutSeconds?: number | undefined;
+  actorId?: string | undefined;
+}
+export type HarnessReasoningContentBlockDelta =
+  | HarnessReasoningContentBlockDelta.RedactedContentMember
+  | HarnessReasoningContentBlockDelta.SignatureMember
+  | HarnessReasoningContentBlockDelta.TextMember
+  | HarnessReasoningContentBlockDelta.$UnknownMember;
+export declare namespace HarnessReasoningContentBlockDelta {
+  interface TextMember {
+    text: string;
+    redactedContent?: never;
+    signature?: never;
+    $unknown?: never;
+  }
+  interface RedactedContentMember {
+    text?: never;
+    redactedContent: Uint8Array;
+    signature?: never;
+    $unknown?: never;
+  }
+  interface SignatureMember {
+    text?: never;
+    redactedContent?: never;
+    signature: string;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    redactedContent?: never;
+    signature?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    redactedContent: (value: Uint8Array) => T;
+    signature: (value: string) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export type HarnessToolResultBlockDelta =
+  | HarnessToolResultBlockDelta.JsonMember
+  | HarnessToolResultBlockDelta.TextMember
+  | HarnessToolResultBlockDelta.$UnknownMember;
+export declare namespace HarnessToolResultBlockDelta {
+  interface TextMember {
+    text: string;
+    json?: never;
+    $unknown?: never;
+  }
+  interface JsonMember {
+    text?: never;
+    json: __DocumentType;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    json?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    json: (value: __DocumentType) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export interface HarnessToolUseBlockDelta {
+  input: string | undefined;
+}
+export type HarnessContentBlockDelta =
+  | HarnessContentBlockDelta.ReasoningContentMember
+  | HarnessContentBlockDelta.TextMember
+  | HarnessContentBlockDelta.ToolResultMember
+  | HarnessContentBlockDelta.ToolUseMember
+  | HarnessContentBlockDelta.$UnknownMember;
+export declare namespace HarnessContentBlockDelta {
+  interface TextMember {
+    text: string;
+    toolUse?: never;
+    toolResult?: never;
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface ToolUseMember {
+    text?: never;
+    toolUse: HarnessToolUseBlockDelta;
+    toolResult?: never;
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface ToolResultMember {
+    text?: never;
+    toolUse?: never;
+    toolResult: HarnessToolResultBlockDelta[];
+    reasoningContent?: never;
+    $unknown?: never;
+  }
+  interface ReasoningContentMember {
+    text?: never;
+    toolUse?: never;
+    toolResult?: never;
+    reasoningContent: HarnessReasoningContentBlockDelta;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    text?: never;
+    toolUse?: never;
+    toolResult?: never;
+    reasoningContent?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    text: (value: string) => T;
+    toolUse: (value: HarnessToolUseBlockDelta) => T;
+    toolResult: (value: HarnessToolResultBlockDelta[]) => T;
+    reasoningContent: (value: HarnessReasoningContentBlockDelta) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export interface HarnessContentBlockDeltaEvent {
+  contentBlockIndex: number | undefined;
+  delta: HarnessContentBlockDelta | undefined;
+}
+export interface HarnessToolResultBlockStart {
+  toolUseId: string | undefined;
+  status?: HarnessToolUseStatus | undefined;
+}
+export interface HarnessToolUseBlockStart {
+  toolUseId: string | undefined;
+  name: string | undefined;
+  type?: HarnessToolUseType | undefined;
+  serverName?: string | undefined;
+}
+export type HarnessContentBlockStart =
+  | HarnessContentBlockStart.ToolResultMember
+  | HarnessContentBlockStart.ToolUseMember
+  | HarnessContentBlockStart.$UnknownMember;
+export declare namespace HarnessContentBlockStart {
+  interface ToolUseMember {
+    toolUse: HarnessToolUseBlockStart;
+    toolResult?: never;
+    $unknown?: never;
+  }
+  interface ToolResultMember {
+    toolUse?: never;
+    toolResult: HarnessToolResultBlockStart;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    toolUse?: never;
+    toolResult?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    toolUse: (value: HarnessToolUseBlockStart) => T;
+    toolResult: (value: HarnessToolResultBlockStart) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export interface HarnessContentBlockStartEvent {
+  contentBlockIndex: number | undefined;
+  start: HarnessContentBlockStart | undefined;
+}
+export interface HarnessContentBlockStopEvent {
+  contentBlockIndex: number | undefined;
+}
+export interface HarnessMessageStartEvent {
+  role: HarnessConversationRole | undefined;
+}
+export interface HarnessMessageStopEvent {
+  stopReason: HarnessStopReason | undefined;
+}
+export interface HarnessStreamMetrics {
+  latencyMs: number | undefined;
+}
+export interface HarnessTokenUsage {
+  inputTokens: number | undefined;
+  outputTokens: number | undefined;
+  totalTokens: number | undefined;
+  cacheReadInputTokens?: number | undefined;
+  cacheWriteInputTokens?: number | undefined;
+}
+export interface HarnessMetadataEvent {
+  usage: HarnessTokenUsage | undefined;
+  metrics: HarnessStreamMetrics | undefined;
+}
+export type InvokeHarnessStreamOutput =
+  | InvokeHarnessStreamOutput.ContentBlockDeltaMember
+  | InvokeHarnessStreamOutput.ContentBlockStartMember
+  | InvokeHarnessStreamOutput.ContentBlockStopMember
+  | InvokeHarnessStreamOutput.InternalServerExceptionMember
+  | InvokeHarnessStreamOutput.MessageStartMember
+  | InvokeHarnessStreamOutput.MessageStopMember
+  | InvokeHarnessStreamOutput.MetadataMember
+  | InvokeHarnessStreamOutput.RuntimeClientErrorMember
+  | InvokeHarnessStreamOutput.ValidationExceptionMember
+  | InvokeHarnessStreamOutput.$UnknownMember;
+export declare namespace InvokeHarnessStreamOutput {
+  interface MessageStartMember {
+    messageStart: HarnessMessageStartEvent;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    validationException?: never;
+    runtimeClientError?: never;
+    $unknown?: never;
+  }
+  interface ContentBlockStartMember {
+    messageStart?: never;
+    contentBlockStart: HarnessContentBlockStartEvent;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    validationException?: never;
+    runtimeClientError?: never;
+    $unknown?: never;
+  }
+  interface ContentBlockDeltaMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta: HarnessContentBlockDeltaEvent;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    validationException?: never;
+    runtimeClientError?: never;
+    $unknown?: never;
+  }
+  interface ContentBlockStopMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop: HarnessContentBlockStopEvent;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    validationException?: never;
+    runtimeClientError?: never;
+    $unknown?: never;
+  }
+  interface MessageStopMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop: HarnessMessageStopEvent;
+    metadata?: never;
+    internalServerException?: never;
+    validationException?: never;
+    runtimeClientError?: never;
+    $unknown?: never;
+  }
+  interface MetadataMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata: HarnessMetadataEvent;
+    internalServerException?: never;
+    validationException?: never;
+    runtimeClientError?: never;
+    $unknown?: never;
+  }
+  interface InternalServerExceptionMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException: InternalServerException;
+    validationException?: never;
+    runtimeClientError?: never;
+    $unknown?: never;
+  }
+  interface ValidationExceptionMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    validationException: ValidationException;
+    runtimeClientError?: never;
+    $unknown?: never;
+  }
+  interface RuntimeClientErrorMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    validationException?: never;
+    runtimeClientError: RuntimeClientError;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    messageStart?: never;
+    contentBlockStart?: never;
+    contentBlockDelta?: never;
+    contentBlockStop?: never;
+    messageStop?: never;
+    metadata?: never;
+    internalServerException?: never;
+    validationException?: never;
+    runtimeClientError?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    messageStart: (value: HarnessMessageStartEvent) => T;
+    contentBlockStart: (value: HarnessContentBlockStartEvent) => T;
+    contentBlockDelta: (value: HarnessContentBlockDeltaEvent) => T;
+    contentBlockStop: (value: HarnessContentBlockStopEvent) => T;
+    messageStop: (value: HarnessMessageStopEvent) => T;
+    metadata: (value: HarnessMetadataEvent) => T;
+    internalServerException: (value: InternalServerException) => T;
+    validationException: (value: ValidationException) => T;
+    runtimeClientError: (value: RuntimeClientError) => T;
+    _: (name: string, value: any) => T;
+  }
+}
+export interface InvokeHarnessResponse {
+  stream: AsyncIterable<InvokeHarnessStreamOutput> | undefined;
+}
 export type MemoryContent =
   | MemoryContent.TextMember
   | MemoryContent.$UnknownMember;