Services

import { Effect } from "effect";
import { OrchestrationEngineService } from "./orchestration/Services/OrchestrationEngine";

const program = Effect.gen(function* () {
  const engine = yield* OrchestrationEngineService;
  
  // Read current state
  const readModel = yield* engine.getReadModel();
  console.log(`Active threads: ${readModel.threads.length}`);
  
  // Dispatch a command
  const result = yield* engine.dispatch({
    _tag: "OrchestrationCommand.CreateThread",
    commandId: "cmd-123",
    // ... command payload
  });
  console.log(`Event persisted at sequence: ${result.sequence}`);
});

const program = Effect.gen(function* () {
  const query = yield* ProjectionSnapshotQuery;
  const snapshot = yield* query.getSnapshot();
  
  console.log(`Sequence: ${snapshot.sequence}`);
  console.log(`Projects: ${snapshot.projects.length}`);
  console.log(`Threads: ${snapshot.threads.length}`);
});

import { Effect, Stream } from "effect";
import { ProviderService } from "./provider/Services/ProviderService";

const program = Effect.gen(function* () {
  const provider = yield* ProviderService;
  
  // Start a session
  const session = yield* provider.startSession(threadId, {
    provider: "codex",
    model: "o3-mini",
    mode: "streaming",
    // ... other options
  });
  
  // Send a turn
  const turn = yield* provider.sendTurn({
    threadId,
    messages: [{ role: "user", content: "Hello" }],
  });
  
  // Stream events
  yield* Stream.runForEach(provider.streamEvents, (event) =>
    Effect.log(`Event: ${event._tag}`)
  );
});

import { makeServerProviderLayer } from "./serverLayers";

const providerLayer = makeServerProviderLayer();

import { makeServerRuntimeServicesLayer } from "./serverLayers";

const runtimeLayer = makeServerRuntimeServicesLayer();

import { Layer } from "effect";
import { makeServerProviderLayer, makeServerRuntimeServicesLayer } from "./serverLayers";
import { SqlitePersistenceMemory } from "./persistence/Layers/Sqlite";

const fullServerLayer = Layer.empty.pipe(
  Layer.provideMerge(makeServerRuntimeServicesLayer()),
  Layer.provideMerge(makeServerProviderLayer()),
  Layer.provideMerge(SqlitePersistenceMemory),
);

const program = Effect.gen(function* () {
  const engine = yield* OrchestrationEngineService;
  const provider = yield* ProviderService;
  // Use services...
}).pipe(Effect.provide(fullServerLayer));