@mozaik-ai/core 3.5.1 → 3.6.0

package/dist/index.mjs

@@ -447,74 +447,6 @@ var Gpt54Mini = class {
   }
 };
 
-// src/domain/specification/specification/specification.ts
-var BaseSpecification = class {
-  and(other) {
-    return new AndSpecification(this, other);
-  }
-  or(other) {
-    return new OrSpecification(this, other);
-  }
-  not() {
-    return new NotSpecification(this);
-  }
-};
-var AndSpecification = class extends BaseSpecification {
-  constructor(left, right) {
-    super();
-    this.left = left;
-    this.right = right;
-  }
-  isSatisfiedBy(candidate) {
-    return this.left.isSatisfiedBy(candidate) && this.right.isSatisfiedBy(candidate);
-  }
-};
-var NotSpecification = class extends BaseSpecification {
-  constructor(specification) {
-    super();
-    this.specification = specification;
-  }
-  isSatisfiedBy(candidate) {
-    return !this.specification.isSatisfiedBy(candidate);
-  }
-};
-var OrSpecification = class extends BaseSpecification {
-  constructor(left, right) {
-    super();
-    this.left = left;
-    this.right = right;
-  }
-  isSatisfiedBy(candidate) {
-    return this.left.isSatisfiedBy(candidate) || this.right.isSatisfiedBy(candidate);
-  }
-};
-
-// src/domain/specification/rule/rule.ts
-var If = class {
-  constructor({ specification, action }) {
-    this.specification = specification;
-    this.action = action;
-  }
-  async apply(candidate) {
-    if (this.specification.isSatisfiedBy(candidate)) {
-      return await this.action.apply(candidate);
-    }
-    return candidate;
-  }
-};
-var Loop = class {
-  constructor({ specification, action }) {
-    this.specification = specification;
-    this.action = action;
-  }
-  async apply(candidate) {
-    while (this.specification.isSatisfiedBy(candidate)) {
-      candidate = await this.action.apply(candidate);
-    }
-    return candidate;
-  }
-};
-
 // src/infrastructure/repository/in-memory-model-context-repository.ts
 var InMemoryModelContextRepository = class {
   constructor() {
@@ -557,452 +489,6 @@ var InMemoryModelContextRepository = class {
   }
 };
 
-// src/domain/agent-loop/execution.ts
-var Execution = class _Execution {
-  constructor(executionId, currentStateId, previousStateId, status, stepCount, retryCounts, history) {
-    this.executionId = executionId;
-    this.currentStateId = currentStateId;
-    this.previousStateId = previousStateId;
-    this.status = status;
-    this.stepCount = stepCount;
-    this.retryCounts = retryCounts;
-    this.history = history;
-  }
-  isTerminal() {
-    return this.status == 1 /* COMPLETED */ || this.status == 2 /* FAILED */;
-  }
-  static create() {
-    const executionId = crypto.randomUUID();
-    const currentStateId = "INFERENCE_PENDING" /* INFERENCE_PENDING */;
-    const previousStateId = null;
-    const status = 0 /* RUNNING */;
-    const stepCount = 0;
-    const retryCounts = /* @__PURE__ */ new Map();
-    const history = [];
-    return new _Execution(executionId, currentStateId, previousStateId, status, stepCount, retryCounts, history);
-  }
-};
-
-// src/domain/agent-loop/transition/go-to.ts
-var GoTo = class {
-  constructor(next) {
-    this.next = next;
-  }
-  async apply(context) {
-    const execution = context.execution;
-    execution.previousStateId = execution.currentStateId;
-    execution.currentStateId = this.next;
-    execution.stepCount++;
-    execution.history.push({
-      fromState: execution.previousStateId,
-      toState: execution.currentStateId,
-      timestamp: /* @__PURE__ */ new Date(),
-      duration: 0,
-      error: null
-    });
-  }
-};
-
-// src/domain/agent-loop/transition/fail.ts
-var Fail = class {
-  constructor(error) {
-    this.error = error;
-  }
-  async apply(context) {
-    const execution = context.execution;
-    execution.status = 2 /* FAILED */;
-  }
-};
-
-// src/domain/model-context/specifications/function-call-requested.ts
-var FunctionCallRequestedSpec = class extends BaseSpecification {
-  isSatisfiedBy(context) {
-    if (context.getItems().length === 0) {
-      return false;
-    }
-    const lastItem = context.getLastItem();
-    return lastItem instanceof FunctionCallItem;
-  }
-};
-
-// src/domain/model-context/specifications/function-call-output-present.ts
-var FunctionCallOutputPresentSpec = class extends BaseSpecification {
-  isSatisfiedBy(context) {
-    const lasteItem = context.getLastItem();
-    return lasteItem instanceof FunctionCallOutputItem;
-  }
-};
-
-// src/domain/agent-loop/state/function-call-pending.ts
-var FunctionCallPendingState = class {
-  constructor() {
-    this.id = "FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */;
-    this.beforeHookId = "BEFORE_FUNCTION_CALL" /* BEFORE_FUNCTION_CALL */;
-    this.afterHookId = "AFTER_FUNCTION_CALL" /* AFTER_FUNCTION_CALL */;
-    this.functionCallRequestedSpec = new FunctionCallRequestedSpec();
-    this.functionCallOutputPresentSpec = new FunctionCallOutputPresentSpec();
-  }
-  getDetails() {
-    return {
-      before: this.beforeHookId,
-      stateId: this.id,
-      after: this.afterHookId
-    };
-  }
-  validateEntry(runtime) {
-    if (!this.functionCallRequestedSpec.isSatisfiedBy(runtime.context)) {
-      throw new Error("Function call requested not found");
-    }
-  }
-  next(runtime) {
-    if (!this.functionCallOutputPresentSpec.isSatisfiedBy(runtime.context)) {
-      return new Fail("Function call output not found");
-    }
-    return new GoTo("INFERENCE_PENDING" /* INFERENCE_PENDING */);
-  }
-};
-
-// src/domain/agent-loop/transition/complete.ts
-var Complete = class {
-  constructor(result) {
-    this.result = result;
-  }
-  async apply(context) {
-    const execution = context.execution;
-    execution.status = 1 /* COMPLETED */;
-  }
-};
-
-// src/domain/model-context/specifications/model-responded.ts
-var ModelRespondedSpec = class extends BaseSpecification {
-  isSatisfiedBy(context) {
-    if (context.getItems().length === 0) {
-      return false;
-    }
-    const lastItem = context.getLastItem();
-    return lastItem instanceof ModelMessageItem && lastItem.role === "assistant";
-  }
-};
-
-// src/domain/agent-loop/state/model-responded.ts
-var ModelRespondedState = class {
-  constructor() {
-    this.id = "MODEL_RESPONDED" /* MODEL_RESPONDED */;
-    this.beforeHookId = "BEFORE_MODEL_RESPONDED" /* BEFORE_MODEL_RESPONDED */;
-    this.afterHookId = "AFTER_MODEL_RESPONDED" /* AFTER_MODEL_RESPONDED */;
-    this.modelRespondedSpec = new ModelRespondedSpec();
-  }
-  getDetails() {
-    return {
-      before: this.beforeHookId,
-      stateId: this.id,
-      after: this.afterHookId
-    };
-  }
-  validateEntry(runtime) {
-    if (!this.modelRespondedSpec.isSatisfiedBy(runtime.context)) {
-      throw new Error("Model message is not present in the context");
-    }
-  }
-  next(runtime) {
-    if (!this.modelRespondedSpec.isSatisfiedBy(runtime.context)) {
-      return new Fail("Model message is not present in the context");
-    }
-    const lastItem = runtime.context.getLastItem();
-    return new Complete(lastItem.content.text);
-  }
-};
-
-// src/domain/agent-loop/state/inference-pending.ts
-var InferencePendingState = class {
-  constructor() {
-    this.id = "INFERENCE_PENDING" /* INFERENCE_PENDING */;
-    this.beforeHookId = "BEFORE_INFERENCE" /* BEFORE_INFERENCE */;
-    this.afterHookId = "AFTER_INFERENCE" /* AFTER_INFERENCE */;
-    this.functionCallRequested = new FunctionCallRequestedSpec();
-    this.modelResponded = new ModelRespondedSpec();
-  }
-  getDetails() {
-    return {
-      before: this.beforeHookId,
-      stateId: this.id,
-      after: this.afterHookId
-    };
-  }
-  validateEntry(runtime) {
-  }
-  next(runtime) {
-    if (this.functionCallRequested.isSatisfiedBy(runtime.context)) {
-      return new GoTo("FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */);
-    } else if (this.modelResponded.isSatisfiedBy(runtime.context)) {
-      return new GoTo("MODEL_RESPONDED" /* MODEL_RESPONDED */);
-    }
-    return new Fail("Invalid response type");
-  }
-};
-
-// src/domain/agent-loop/state/message-received.ts
-var MessageReceivedState = class {
-  constructor() {
-    this.id = "MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */;
-    this.beforeHookId = "BEFORE_MESSAGE_RECEIVED" /* BEFORE_MESSAGE_RECEIVED */;
-    this.afterHookId = "AFTER_MESSAGE_RECEIVED" /* AFTER_MESSAGE_RECEIVED */;
-  }
-  getDetails() {
-    return {
-      before: this.beforeHookId,
-      stateId: this.id,
-      after: this.afterHookId
-    };
-  }
-  validateEntry(context) {
-  }
-  next(context) {
-    return new GoTo("INFERENCE_PENDING" /* INFERENCE_PENDING */);
-  }
-};
-
-// src/domain/agent-loop/agent-loop.ts
-var AgentLoop = class {
-  constructor() {
-    this.states = /* @__PURE__ */ new Map();
-    this.states.set("MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, new MessageReceivedState());
-    this.states.set("INFERENCE_PENDING" /* INFERENCE_PENDING */, new InferencePendingState());
-    this.states.set("FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */, new FunctionCallPendingState());
-    this.states.set("MODEL_RESPONDED" /* MODEL_RESPONDED */, new ModelRespondedState());
-  }
-  getState(runtime) {
-    const state = this.states.get(runtime.execution.currentStateId);
-    if (!state) {
-      throw new Error(`State ${runtime.execution.currentStateId} not found`);
-    }
-    return state;
-  }
-};
-
-// src/domain/agent-loop/hooks/hooks-registry.ts
-var HooksRegistry = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
-  }
-  getHandler(hookId) {
-    const handler = this.handlers.get(hookId);
-    if (!handler) {
-      throw new Error(`Hook handler for hook ${hookId} not found`);
-    }
-    return handler;
-  }
-  registerHandler(hookId, handler) {
-    this.handlers.set(hookId, handler);
-  }
-  unregisterHandler(hookId) {
-    this.handlers.delete(hookId);
-  }
-};
-
-// src/domain/agent-loop/state/state-registry.ts
-var StateHandlerRegistry = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
-  }
-  getHandler(stateId) {
-    const handler = this.handlers.get(stateId);
-    if (!handler) {
-      throw new Error(`Handler for state ${stateId} not found`);
-    }
-    return handler;
-  }
-  registerHandler(stateId, handler) {
-    this.handlers.set(stateId, handler);
-  }
-  unregisterHandler(stateId) {
-    this.handlers.delete(stateId);
-  }
-};
-
-// src/application/agent-runtime.ts
-var AgentRuntime = class {
-  constructor() {
-    this.hooksRegistry = new HooksRegistry();
-    this.stateHandlerRegistry = new StateHandlerRegistry();
-    this.stateHandlerRegistry.registerHandler("MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, this.onMessageReceived);
-    this.stateHandlerRegistry.registerHandler("INFERENCE_PENDING" /* INFERENCE_PENDING */, this.onInferencePending);
-    this.stateHandlerRegistry.registerHandler("FUNCTION_CALL_PENDING" /* FUNCTION_CALL_PENDING */, this.onFunctionCallPending);
-    this.stateHandlerRegistry.registerHandler("MODEL_RESPONDED" /* MODEL_RESPONDED */, this.onModelResponded);
-    this.hooksRegistry.registerHandler("ON_ERROR" /* ON_ERROR */, this.onError);
-  }
-  async onMessageReceived(runtimeContext) {
-    return Promise.resolve();
-  }
-  async onInferencePending(runtimeContext) {
-    const openaiResponses = new OpenAIResponses();
-    const inferenceRequest = new InferenceRequest(runtimeContext.model, runtimeContext.context);
-    const inferenceResponse = await openaiResponses.infer(inferenceRequest);
-    runtimeContext.inferenceResponse = inferenceResponse;
-    runtimeContext.context.applyModelOutput(inferenceResponse.contextItems);
-    return Promise.resolve();
-  }
-  async onFunctionCallPending(runtimeContext) {
-    const functionCall = runtimeContext.context.getLastItem();
-    const tool = runtimeContext.model.getTools().find((tool2) => tool2.name === functionCall.name);
-    if (!tool) {
-      throw new Error("Function not found");
-    }
-    const functionCallOutput = await tool.invoke(functionCall.args);
-    runtimeContext.context.addContextItem(
-      FunctionCallOutputItem.create(functionCall.callId, JSON.stringify(functionCallOutput))
-    );
-    return Promise.resolve();
-  }
-  async onError(context) {
-    const error = context.error;
-    if (!error) {
-      throw new Error("Error not found");
-    }
-    console.error(error);
-    return Promise.resolve();
-  }
-  async onModelResponded(context) {
-    return Promise.resolve();
-  }
-  async on(hookId, callback) {
-    this.hooksRegistry.registerHandler(hookId, callback);
-  }
-  async start(userMessage, model, context) {
-    console.log("Starting agent runtime");
-    const execution = Execution.create();
-    const loop = new AgentLoop();
-    const runtimeContext = {
-      execution,
-      userMessage,
-      model,
-      context
-    };
-    while (!execution.isTerminal()) {
-      console.log("Executing state", execution.currentStateId);
-      const state = loop.getState(runtimeContext);
-      try {
-        state.validateEntry(runtimeContext);
-        const stateDetails = state.getDetails();
-        if (stateDetails.before) {
-          const handler = this.hooksRegistry.getHandler(stateDetails.before);
-          await handler(runtimeContext);
-        }
-        const stateHandler = this.stateHandlerRegistry.getHandler(execution.currentStateId);
-        await stateHandler(runtimeContext);
-        if (stateDetails.after) {
-          const handler = this.hooksRegistry.getHandler(stateDetails.after);
-          await handler(runtimeContext);
-        }
-      } catch (error) {
-        console.log("Error occurred", error);
-        execution.status = 2 /* FAILED */;
-        const handler = this.hooksRegistry.getHandler("ON_ERROR" /* ON_ERROR */);
-        runtimeContext.error = error;
-        await handler(runtimeContext);
-      }
-      const transition = state.next(runtimeContext);
-      await transition.apply(runtimeContext);
-    }
-  }
-};
-
-// src/application/agent.ts
-var Agent = class {
-  constructor() {
-    this.runtime = new AgentRuntime();
-    this.runtime.on("BEFORE_MESSAGE_RECEIVED" /* BEFORE_MESSAGE_RECEIVED */, this.beforeMessageReceived);
-    this.runtime.on("AFTER_MESSAGE_RECEIVED" /* AFTER_MESSAGE_RECEIVED */, this.afterMessageReceived);
-    this.runtime.on("BEFORE_INFERENCE" /* BEFORE_INFERENCE */, this.beforeInference);
-    this.runtime.on("AFTER_INFERENCE" /* AFTER_INFERENCE */, this.afterInference);
-    this.runtime.on("BEFORE_FUNCTION_CALL" /* BEFORE_FUNCTION_CALL */, this.beforeFunctionCall);
-    this.runtime.on("AFTER_FUNCTION_CALL" /* AFTER_FUNCTION_CALL */, this.afterFunctionCall);
-    this.runtime.on("BEFORE_MODEL_RESPONDED" /* BEFORE_MODEL_RESPONDED */, this.beforeModelResponded);
-    this.runtime.on("AFTER_MODEL_RESPONDED" /* AFTER_MODEL_RESPONDED */, this.afterModelResponded);
-    this.runtime.on("ON_ERROR" /* ON_ERROR */, this.onError);
-  }
-  async beforeMessageReceived(context) {
-    return Promise.resolve();
-  }
-  async afterMessageReceived(context) {
-    return Promise.resolve();
-  }
-  async beforeInference(context) {
-    return Promise.resolve();
-  }
-  async afterInference(context) {
-    const inferenceResponse = context.inferenceResponse;
-    if (inferenceResponse && this.visitor !== void 0) {
-      await this.visitor.afterInference(inferenceResponse);
-    }
-    return Promise.resolve();
-  }
-  async beforeFunctionCall(context) {
-    if (this.functionCallVisitor !== void 0) {
-      await this.functionCallVisitor.beforeFunctionCall(context);
-    }
-    return Promise.resolve();
-  }
-  async afterFunctionCall(context) {
-    if (this.functionCallVisitor !== void 0) {
-      await this.functionCallVisitor.afterFunctionCall(context);
-    }
-    return Promise.resolve();
-  }
-  async beforeModelResponded(context) {
-    return Promise.resolve();
-  }
-  async afterModelResponded(context) {
-    return Promise.resolve();
-  }
-  async onError(context) {
-    console.log("Error occurred", context.error);
-    return Promise.resolve();
-  }
-  async onStart(context) {
-    if (this.visitor !== void 0) {
-      await this.visitor.onStart(context);
-    }
-    return Promise.resolve();
-  }
-  setInferenceVisitor(visitor) {
-    this.visitor = visitor;
-  }
-  setFunctionCallVisitor(visitor) {
-    this.functionCallVisitor = visitor;
-  }
-  async run(userMessage, model, context) {
-    const userMessageItem = UserMessageItem.create(userMessage);
-    return this.runtime.start(userMessageItem, model, context);
-  }
-};
-
-// src/application/agent-society.ts
-var AgentSociety = class {
-  constructor(name) {
-    this.name = name;
-    this.agents = [];
-    this.isActive = false;
-  }
-  join(agent) {
-    this.agents.push(agent);
-  }
-  enter(messageText, model, context) {
-    for (const agent of this.agents) {
-      agent.run(messageText, model, context);
-    }
-  }
-  async start() {
-    this.isActive = true;
-    while (this.isActive) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  }
-  stop() {
-    this.isActive = false;
-  }
-};
-
 // src/domain/model-context/context-item/client-item/system-message.ts
 var SystemMessageItem = class _SystemMessageItem extends ContextItem {
   constructor(content) {
@@ -1030,56 +516,26 @@ var SystemMessageItem = class _SystemMessageItem extends ContextItem {
 
 // src/domain/agentic-environment/participant.ts
 var Participant = class {
-  constructor(toolExecutor, messageSender, inferenceHandler) {
+  constructor() {
     this.environments = [];
-    this.toolExecutor = toolExecutor;
-    this.messageSender = messageSender;
-    this.inferenceHandler = inferenceHandler;
-  }
-  async sendMessage(message, environment) {
-    if (!this.environments.includes(environment)) {
-      return;
-    }
-    for await (const messagePart of this.messageSender.stream(message)) {
-      environment.notifyMessage(this, messagePart);
-    }
-  }
-  async executeFunctionCall(functionCallItem, environment) {
-    if (!this.environments.includes(environment)) {
-      return;
-    }
-    for await (const item of this.toolExecutor.produce(functionCallItem)) {
-      environment.notifyFunctionCallOutput(this, item);
-    }
-  }
-  async runInference(environment, context, model, signal) {
-    if (!this.environments.includes(environment)) {
-      return;
-    }
-    for await (const item of this.inferenceHandler.produce(context, model, signal)) {
-      if (item instanceof FunctionCallItem) {
-        environment.notifyFunctionCall(this, item);
-      } else if (item instanceof ReasoningItem) {
-        environment.notifyReasoning(this, item);
-      } else if (item instanceof ModelMessageItem) {
-        environment.notifyOutputMessage(this, item);
-      }
-    }
   }
   join(environment) {
-    if (this.environments.includes(environment)) {
+    if (this.isJoinedTo(environment)) {
       return;
     }
     environment.subscribe(this);
     this.environments.push(environment);
   }
   leave(environment) {
-    if (!this.environments.includes(environment)) {
+    if (!this.isJoinedTo(environment)) {
       return;
     }
     environment.unsubscribe(this);
     this.environments = this.environments.filter((e) => e !== environment);
   }
+  isJoinedTo(environment) {
+    return this.environments.includes(environment);
+  }
 };
 
 // src/domain/agentic-environment/agentic-environment.ts
@@ -1088,6 +544,17 @@ var AgenticEnvironment = class {
     this.subscribers = [];
     this.isActive = false;
   }
+  subscribe(subscriber) {
+    this.subscribers.push(subscriber);
+  }
+  unsubscribe(user) {
+    this.subscribers = this.subscribers.filter((p) => p !== user);
+  }
+  deliverContextItem(source, item) {
+    for (const subscriber of this.subscribers) {
+      subscriber.onContextItem(source, item);
+    }
+  }
   async start() {
     this.isActive = true;
     while (this.isActive) {
@@ -1097,46 +564,74 @@ var AgenticEnvironment = class {
   stop() {
     this.isActive = false;
   }
-  subscribe(subscriber) {
-    this.subscribers.push(subscriber);
+};
+
+// src/application/deliver-stream.ts
+async function deliverStream(environment, initiator, stream) {
+  for await (const item of stream) {
+    await environment.deliverContextItem(initiator, item);
   }
-  unsubscribe(user) {
-    this.subscribers = this.subscribers.filter((p) => p !== user);
+}
+
+// src/application/agent.ts
+var BaseAgentParticipant = class extends Participant {
+  constructor(inputSource, inferenceRunner, functionCallRunner) {
+    super();
+    this.inputSource = inputSource;
+    this.inferenceRunner = inferenceRunner;
+    this.functionCallRunner = functionCallRunner;
   }
-  notifyFunctionCallOutput(user, item) {
-    for (const subscriber of this.subscribers) {
-      subscriber.onFunctionCallOutput(subscriber, item);
-    }
+  onContextItem(source, item) {
+    return Promise.resolve();
   }
-  notifyMessage(user, message) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === user) {
-        continue;
-      }
-      subscriber.onMessage(subscriber, message);
-    }
+  async executeFunctionCall(environment, functionCallItem, signal) {
+    if (!this.isJoinedTo(environment)) return;
+    await deliverStream(
+      environment,
+      this,
+      this.functionCallRunner.run(functionCallItem, signal)
+    );
   }
-  notifyFunctionCall(user, item) {
-    for (const subscriber of this.subscribers) {
-      subscriber.onFunctionCall(user, item);
-    }
+  async runInference(environment, context, model, signal) {
+    if (!this.isJoinedTo(environment)) return;
+    await deliverStream(
+      environment,
+      this,
+      this.inferenceRunner.run(context, model, signal)
+    );
   }
-  notifyReasoning(user, item) {
-    for (const subscriber of this.subscribers) {
-      subscriber.onReasoning(user, item);
-    }
+  async streamInput(environment) {
+    if (!this.isJoinedTo(environment)) return;
+    await deliverStream(
+      environment,
+      this,
+      this.inputSource.stream()
+    );
   }
-  notifyOutputMessage(user, item) {
-    for (const subscriber of this.subscribers) {
-      subscriber.onOutputMessage(user, item);
-    }
+};
+
+// src/application/human.ts
+var BaseHumanParticipant = class extends Participant {
+  constructor(inputSource) {
+    super();
+    this.inputSource = inputSource;
+  }
+  onContextItem(source, item) {
+    return Promise.resolve();
+  }
+  async streamInput(environment) {
+    if (!this.isJoinedTo(environment)) return;
+    await deliverStream(
+      environment,
+      this,
+      this.inputSource.stream()
+    );
   }
 };
 export {
-  Agent,
-  AgentSociety,
   AgenticEnvironment,
-  BaseSpecification,
+  BaseAgentParticipant,
+  BaseHumanParticipant,
   ContextItem,
   DeveloperMessageItem,
   FunctionCallItem,
@@ -1144,12 +639,10 @@ export {
   Gpt54,
   Gpt54Mini,
   Gpt54Nano,
-  If,
   InMemoryModelContextRepository,
   InferenceRequest,
   InferenceResponse,
   InputTokenDetails,
-  Loop,
   ModelContext,
   ModelMessageItem,
   OpenAIResponses,