@pooder/core 2.0.0 → 2.2.0

package/dist/index.mjs

@@ -1,20 +1,108 @@
 // src/service.ts
+function createServiceToken(name) {
+  if (!name) {
+    throw new Error("Service token name is required.");
+  }
+  return Object.freeze({
+    kind: "service-token",
+    key: Symbol(name),
+    name
+  });
+}
+function isServiceToken(identifier) {
+  return typeof identifier === "object" && identifier !== null && "kind" in identifier && identifier.kind === "service-token";
+}
 var ServiceRegistry = class {
   constructor() {
-    this.services = /* @__PURE__ */ new Map();
+    this.servicesByName = /* @__PURE__ */ new Map();
+    this.servicesByToken = /* @__PURE__ */ new Map();
+    this.registrationOrder = [];
   }
-  register(name, service) {
-    this.services.set(name, service);
+  register(identifier, service, options = {}) {
+    const normalized = this.normalizeIdentifier(identifier);
+    const existing = this.findEntry(normalized);
+    if (existing && !options.allowOverride) {
+      throw new Error(`Service "${normalized.name}" is already registered.`);
+    }
+    if (existing) {
+      this.removeEntry(existing);
+    }
+    const entry = {
+      token: normalized.token,
+      name: normalized.name,
+      service
+    };
+    this.servicesByName.set(entry.name, entry);
+    if (entry.token) {
+      this.servicesByToken.set(entry.token.key, entry);
+    }
+    this.registrationOrder.push(entry);
     return service;
   }
-  get(serviceName) {
-    return this.services.get(serviceName);
+  get(identifier) {
+    const normalized = this.normalizeIdentifier(identifier);
+    const entry = this.findEntry(normalized);
+    return entry == null ? void 0 : entry.service;
+  }
+  getOrThrow(identifier, errorMessage) {
+    const service = this.get(identifier);
+    if (service) {
+      return service;
+    }
+    const normalized = this.normalizeIdentifier(identifier);
+    throw new Error(errorMessage != null ? errorMessage : `Service "${normalized.name}" not found.`);
   }
-  has(serviceName) {
-    return this.services.has(serviceName);
+  has(identifier) {
+    const normalized = this.normalizeIdentifier(identifier);
+    return Boolean(this.findEntry(normalized));
   }
-  delete(serviceName) {
-    this.services.delete(serviceName);
+  delete(identifier) {
+    const normalized = this.normalizeIdentifier(identifier);
+    const entry = this.findEntry(normalized);
+    if (!entry) {
+      return false;
+    }
+    this.removeEntry(entry);
+    return true;
+  }
+  list() {
+    return this.registrationOrder.map((entry) => ({
+      id: entry.name,
+      token: entry.token,
+      service: entry.service
+    }));
+  }
+  clear() {
+    this.servicesByName.clear();
+    this.servicesByToken.clear();
+    this.registrationOrder.length = 0;
+  }
+  findEntry(identifier) {
+    var _a;
+    if (identifier.token) {
+      return (_a = this.servicesByToken.get(identifier.token.key)) != null ? _a : this.servicesByName.get(identifier.name);
+    }
+    return this.servicesByName.get(identifier.name);
+  }
+  normalizeIdentifier(identifier) {
+    if (isServiceToken(identifier)) {
+      return { token: identifier, name: identifier.name };
+    }
+    const name = identifier.trim();
+    if (!name) {
+      throw new Error("Service identifier must be a non-empty string.");
+    }
+    return { name };
+  }
+  removeEntry(entry) {
+    this.servicesByName.delete(entry.name);
+    if (entry.token) {
+      this.servicesByToken.delete(entry.token.key);
+    }
+    const index = this.registrationOrder.lastIndexOf(entry);
+    if (index >= 0) {
+      this.registrationOrder.splice(index, 1);
+    }
   }
 };
 
@@ -172,122 +260,6 @@ var ContributionRegistry = class {
   }
 };
 
-// src/extension.ts
-var ExtensionRegistry = class extends Map {
-};
-var ExtensionManager = class {
-  constructor(context) {
-    this.extensionRegistry = new ExtensionRegistry();
-    this.extensionDisposables = /* @__PURE__ */ new Map();
-    this.context = context;
-  }
-  register(extension) {
-    if (this.extensionRegistry.has(extension.id)) {
-      console.warn(
-        `Plugin "${extension.id}" already registered. It will be overwritten.`
-      );
-    }
-    this.extensionDisposables.set(extension.id, []);
-    const disposables = this.extensionDisposables.get(extension.id);
-    if (extension.contribute) {
-      for (const [pointId, items] of Object.entries(extension.contribute())) {
-        if (Array.isArray(items)) {
-          items.forEach((item, index) => {
-            const contributionId = item.id || (item.command ? item.command : `${extension.id}.${pointId}.${index}`);
-            const contribution = {
-              id: contributionId,
-              metadata: {
-                extensionId: extension.id,
-                ...item == null ? void 0 : item.metadata
-              },
-              data: item
-            };
-            const disposable = this.context.contributions.register(
-              pointId,
-              contribution
-            );
-            disposables.push(disposable);
-            const dispose = this.collectContribution(pointId, contribution);
-            if (dispose) {
-              disposables.push(dispose);
-            }
-          });
-        }
-      }
-    }
-    try {
-      this.extensionRegistry.set(extension.id, extension);
-      this.context.eventBus.emit("extension:register", extension);
-    } catch (error) {
-      console.error(
-        `Error in onCreate hook for plugin "${extension.id}":`,
-        error
-      );
-    }
-    try {
-      extension.activate(this.context);
-    } catch (error) {
-      console.error(
-        `Error in onActivate hook for plugin "${extension.id}":`,
-        error
-      );
-    }
-    console.log(`Plugin "${extension.id}" registered successfully`);
-  }
-  collectContribution(pointId, item) {
-    if (pointId === ContributionPointIds.CONFIGURATIONS) {
-      const configService = this.context.services.get(
-        "ConfigurationService"
-      );
-      configService == null ? void 0 : configService.initializeDefaults([item.data]);
-    }
-    if (pointId === ContributionPointIds.COMMANDS && item.data.handler) {
-      const commandService = this.context.services.get("CommandService");
-      return commandService.registerCommand(item.id, item.data.handler);
-    }
-  }
-  unregister(name) {
-    const extension = this.extensionRegistry.get(name);
-    if (!extension) {
-      console.warn(`Plugin "${name}" not found.`);
-      return;
-    }
-    try {
-      extension.deactivate(this.context);
-    } catch (error) {
-      console.error(`Error in deactivate for plugin "${name}":`, error);
-    }
-    const disposables = this.extensionDisposables.get(name);
-    if (disposables) {
-      disposables.forEach((d) => d.dispose());
-      this.extensionDisposables.delete(name);
-    }
-    this.extensionRegistry.delete(name);
-    console.log(`Plugin "${name}" unregistered`);
-    return true;
-  }
-  enable(name) {
-    const extension = this.extensionRegistry.get(name);
-    if (!extension) {
-      console.warn(`Plugin "${name}" not found.`);
-      return;
-    }
-  }
-  disable(name) {
-    const extension = this.extensionRegistry.get(name);
-    if (!extension) {
-      console.warn(`Plugin "${name}" not found.`);
-      return;
-    }
-  }
-  update() {
-  }
-  destroy() {
-    const extensionNames = Array.from(this.extensionRegistry.keys());
-    extensionNames.forEach((name) => this.unregister(name));
-  }
-};
-
 // src/services/CommandService.ts
 var CommandService = class {
   constructor() {
@@ -447,27 +419,486 @@ var ConfigurationService = class {
   }
 };
 
+// src/services/ToolRegistryService.ts
+var ToolRegistryService = class {
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+  }
+  registerTool(tool) {
+    if (!(tool == null ? void 0 : tool.id)) {
+      throw new Error("ToolContribution.id is required.");
+    }
+    this.tools.set(tool.id, tool);
+    return {
+      dispose: () => {
+        if (this.tools.get(tool.id) === tool) {
+          this.tools.delete(tool.id);
+        }
+      }
+    };
+  }
+  unregisterTool(toolId) {
+    this.tools.delete(toolId);
+  }
+  getTool(toolId) {
+    return this.tools.get(toolId);
+  }
+  listTools() {
+    return Array.from(this.tools.values());
+  }
+  hasTool(toolId) {
+    return this.tools.has(toolId);
+  }
+  dispose() {
+    this.tools.clear();
+  }
+};
+
+// src/services/tokens.ts
+var COMMAND_SERVICE = createServiceToken(
+  "CommandService"
+);
+var CONFIGURATION_SERVICE = createServiceToken(
+  "ConfigurationService"
+);
+var TOOL_REGISTRY_SERVICE = createServiceToken("ToolRegistryService");
+var TOOL_SESSION_SERVICE = createServiceToken("ToolSessionService");
+var WORKBENCH_SERVICE = createServiceToken("WorkbenchService");
+var CORE_SERVICE_TOKENS = {
+  COMMAND: COMMAND_SERVICE,
+  CONFIGURATION: CONFIGURATION_SERVICE,
+  TOOL_REGISTRY: TOOL_REGISTRY_SERVICE,
+  TOOL_SESSION: TOOL_SESSION_SERVICE,
+  WORKBENCH: WORKBENCH_SERVICE
+};
+
+// src/services/ToolSessionService.ts
+var ToolSessionService = class {
+  constructor(dependencies = {}) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.dirtyTrackers = /* @__PURE__ */ new Map();
+    this.commandService = dependencies.commandService;
+    this.toolRegistry = dependencies.toolRegistry;
+  }
+  init(context) {
+    var _a, _b;
+    (_a = this.commandService) != null ? _a : this.commandService = context.get(COMMAND_SERVICE);
+    (_b = this.toolRegistry) != null ? _b : this.toolRegistry = context.get(TOOL_REGISTRY_SERVICE);
+    if (!this.commandService) {
+      throw new Error("ToolSessionService requires CommandService.");
+    }
+    if (!this.toolRegistry) {
+      throw new Error("ToolSessionService requires ToolRegistryService.");
+    }
+  }
+  setCommandService(commandService) {
+    this.commandService = commandService;
+  }
+  setToolRegistry(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+  }
+  registerDirtyTracker(toolId, callback) {
+    const wrapped = () => {
+      try {
+        return callback();
+      } catch (e) {
+        return false;
+      }
+    };
+    this.dirtyTrackers.set(toolId, wrapped);
+    return {
+      dispose: () => {
+        if (this.dirtyTrackers.get(toolId) === wrapped) {
+          this.dirtyTrackers.delete(toolId);
+        }
+      }
+    };
+  }
+  ensureSession(toolId) {
+    const existing = this.sessions.get(toolId);
+    if (existing) return existing;
+    const created = {
+      toolId,
+      status: "idle",
+      dirty: false
+    };
+    this.sessions.set(toolId, created);
+    return created;
+  }
+  getState(toolId) {
+    return { ...this.ensureSession(toolId) };
+  }
+  isDirty(toolId) {
+    const tracker = this.dirtyTrackers.get(toolId);
+    if (tracker) return tracker();
+    return this.ensureSession(toolId).dirty;
+  }
+  markDirty(toolId, dirty = true) {
+    const session = this.ensureSession(toolId);
+    session.dirty = dirty;
+    session.lastUpdatedAt = Date.now();
+  }
+  resolveTool(toolId) {
+    return this.getToolRegistry().getTool(toolId);
+  }
+  async runCommand(commandId, ...args) {
+    if (!commandId) return void 0;
+    return await this.getCommandService().executeCommand(commandId, ...args);
+  }
+  getCommandService() {
+    if (!this.commandService) {
+      throw new Error("ToolSessionService is not initialized.");
+    }
+    return this.commandService;
+  }
+  getToolRegistry() {
+    if (!this.toolRegistry) {
+      throw new Error("ToolSessionService is not initialized.");
+    }
+    return this.toolRegistry;
+  }
+  async begin(toolId) {
+    var _a;
+    const tool = this.resolveTool(toolId);
+    const session = this.ensureSession(toolId);
+    if (session.status === "active") return;
+    await this.runCommand((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.begin);
+    session.status = "active";
+    session.startedAt = Date.now();
+    session.lastUpdatedAt = session.startedAt;
+  }
+  async validate(toolId) {
+    var _a;
+    const tool = this.resolveTool(toolId);
+    if (!((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.validate)) {
+      return { ok: true };
+    }
+    const result = await this.runCommand(tool.commands.validate);
+    if (result === false) return { ok: false, result };
+    if (result && typeof result === "object" && "ok" in result) {
+      return { ok: Boolean(result.ok), result };
+    }
+    return { ok: true, result };
+  }
+  async commit(toolId) {
+    var _a;
+    const tool = this.resolveTool(toolId);
+    const validateResult = await this.validate(toolId);
+    if (!validateResult.ok) return validateResult;
+    const result = await this.runCommand((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.commit);
+    const session = this.ensureSession(toolId);
+    session.dirty = false;
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+    return { ok: true, result };
+  }
+  async rollback(toolId) {
+    var _a, _b;
+    const tool = this.resolveTool(toolId);
+    await this.runCommand(((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.rollback) || ((_b = tool == null ? void 0 : tool.commands) == null ? void 0 : _b.reset));
+    const session = this.ensureSession(toolId);
+    session.dirty = false;
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+  }
+  deactivateSession(toolId) {
+    const session = this.ensureSession(toolId);
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+  }
+  async handleBeforeLeave(toolId) {
+    var _a, _b;
+    const tool = this.resolveTool(toolId);
+    if (!tool) return { decision: "allow" };
+    if (tool.interaction !== "session") return { decision: "allow" };
+    const dirty = this.isDirty(toolId);
+    if (!dirty) return { decision: "allow" };
+    const leavePolicy = (_b = (_a = tool.session) == null ? void 0 : _a.leavePolicy) != null ? _b : "block";
+    if (leavePolicy === "commit") {
+      const committed = await this.commit(toolId);
+      if (!committed.ok) {
+        return { decision: "blocked", reason: "session-validation-failed" };
+      }
+      return { decision: "allow" };
+    }
+    if (leavePolicy === "rollback") {
+      await this.rollback(toolId);
+      return { decision: "allow" };
+    }
+    return { decision: "blocked", reason: "session-dirty" };
+  }
+  dispose() {
+    this.sessions.clear();
+    this.dirtyTrackers.clear();
+  }
+};
+
 // src/services/WorkbenchService.ts
 var WorkbenchService = class {
-  constructor() {
+  constructor(dependencies = {}) {
     this._activeToolId = null;
+    this.guards = [];
+    this.eventBus = dependencies.eventBus;
+    this.toolRegistry = dependencies.toolRegistry;
+    this.sessionService = dependencies.sessionService;
   }
-  init() {
+  init(context) {
+    var _a, _b, _c;
+    (_a = this.eventBus) != null ? _a : this.eventBus = context.eventBus;
+    (_b = this.toolRegistry) != null ? _b : this.toolRegistry = context.get(TOOL_REGISTRY_SERVICE);
+    (_c = this.sessionService) != null ? _c : this.sessionService = context.get(TOOL_SESSION_SERVICE);
+    if (!this.eventBus) {
+      throw new Error("WorkbenchService requires EventBus.");
+    }
+    if (!this.toolRegistry) {
+      throw new Error("WorkbenchService requires ToolRegistryService.");
+    }
+    if (!this.sessionService) {
+      throw new Error("WorkbenchService requires ToolSessionService.");
+    }
   }
   dispose() {
+    this.guards = [];
   }
   setEventBus(bus) {
     this.eventBus = bus;
   }
+  setToolRegistry(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+  }
+  setToolSessionService(sessionService) {
+    this.sessionService = sessionService;
+  }
   get activeToolId() {
     return this._activeToolId;
   }
-  activate(id) {
+  registerSwitchGuard(guard, priority = 0) {
+    const item = { guard, priority };
+    this.guards.push(item);
+    this.guards.sort((a, b) => b.priority - a.priority);
+    return {
+      dispose: () => {
+        const index = this.guards.indexOf(item);
+        if (index >= 0) this.guards.splice(index, 1);
+      }
+    };
+  }
+  async runGuards(context) {
+    for (const { guard } of this.guards) {
+      const allowed = await Promise.resolve(guard(context));
+      if (!allowed) return false;
+    }
+    return true;
+  }
+  async switchTool(id, options) {
     var _a;
-    if (this._activeToolId === id) return;
+    const eventBus = this.getEventBus();
+    const toolRegistry = this.getToolRegistry();
+    const sessionService = this.getSessionService();
+    if (this._activeToolId === id) {
+      return { ok: true, from: this._activeToolId, to: id };
+    }
+    if (id && !toolRegistry.hasTool(id)) {
+      return {
+        ok: false,
+        from: this._activeToolId,
+        to: id,
+        reason: `tool-not-registered:${id}`
+      };
+    }
+    const context = {
+      from: this._activeToolId,
+      to: id,
+      reason: options == null ? void 0 : options.reason
+    };
+    const guardAllowed = await this.runGuards(context);
+    if (!guardAllowed) {
+      eventBus.emit("tool:switch:blocked", {
+        ...context,
+        reason: "blocked-by-guard"
+      });
+      return {
+        ok: false,
+        from: this._activeToolId,
+        to: id,
+        reason: "blocked-by-guard"
+      };
+    }
+    if (context.from) {
+      const leaveResult = await sessionService.handleBeforeLeave(context.from);
+      if (leaveResult.decision === "blocked") {
+        eventBus.emit("tool:switch:blocked", {
+          ...context,
+          reason: leaveResult.reason || "session-blocked"
+        });
+        return {
+          ok: false,
+          from: this._activeToolId,
+          to: id,
+          reason: leaveResult.reason || "session-blocked"
+        };
+      }
+      sessionService.deactivateSession(context.from);
+    }
+    if (id) {
+      const tool = toolRegistry.getTool(id);
+      if ((tool == null ? void 0 : tool.interaction) === "session" && ((_a = tool.session) == null ? void 0 : _a.autoBegin) !== false) {
+        await sessionService.begin(id);
+      }
+    }
     const previous = this._activeToolId;
     this._activeToolId = id;
-    (_a = this.eventBus) == null ? void 0 : _a.emit("tool:activated", { id, previous });
+    const reason = options == null ? void 0 : options.reason;
+    eventBus.emit("tool:activated", { id, previous, reason });
+    eventBus.emit("tool:switch", { from: previous, to: id, reason });
+    return { ok: true, from: previous, to: id };
+  }
+  async activate(id) {
+    return await this.switchTool(id, { reason: "activate" });
+  }
+  async deactivate() {
+    return await this.switchTool(null, { reason: "deactivate" });
+  }
+  getEventBus() {
+    if (!this.eventBus) {
+      throw new Error("WorkbenchService is not initialized.");
+    }
+    return this.eventBus;
+  }
+  getToolRegistry() {
+    if (!this.toolRegistry) {
+      throw new Error("WorkbenchService is not initialized.");
+    }
+    return this.toolRegistry;
+  }
+  getSessionService() {
+    if (!this.sessionService) {
+      throw new Error("WorkbenchService is not initialized.");
+    }
+    return this.sessionService;
+  }
+};
+
+// src/extension.ts
+var ExtensionRegistry = class extends Map {
+};
+var ExtensionManager = class {
+  constructor(context) {
+    this.extensionRegistry = new ExtensionRegistry();
+    this.extensionDisposables = /* @__PURE__ */ new Map();
+    this.context = context;
+  }
+  register(extension) {
+    if (this.extensionRegistry.has(extension.id)) {
+      console.warn(
+        `Plugin "${extension.id}" already registered. It will be overwritten.`
+      );
+    }
+    this.extensionDisposables.set(extension.id, []);
+    const disposables = this.extensionDisposables.get(extension.id);
+    if (extension.contribute) {
+      for (const [pointId, items] of Object.entries(extension.contribute())) {
+        if (Array.isArray(items)) {
+          items.forEach((item, index) => {
+            const contributionId = item.id || (item.command ? item.command : `${extension.id}.${pointId}.${index}`);
+            const contribution = {
+              id: contributionId,
+              metadata: {
+                extensionId: extension.id,
+                ...item == null ? void 0 : item.metadata
+              },
+              data: item
+            };
+            const disposable = this.context.contributions.register(
+              pointId,
+              contribution
+            );
+            disposables.push(disposable);
+            const dispose = this.collectContribution(pointId, contribution);
+            if (dispose) {
+              disposables.push(dispose);
+            }
+          });
+        }
+      }
+    }
+    try {
+      this.extensionRegistry.set(extension.id, extension);
+      this.context.eventBus.emit("extension:register", extension);
+    } catch (error) {
+      console.error(
+        `Error in onCreate hook for plugin "${extension.id}":`,
+        error
+      );
+    }
+    try {
+      extension.activate(this.context);
+    } catch (error) {
+      console.error(
+        `Error in onActivate hook for plugin "${extension.id}":`,
+        error
+      );
+    }
+    console.log(`Plugin "${extension.id}" registered successfully`);
+  }
+  collectContribution(pointId, item) {
+    if (pointId === ContributionPointIds.CONFIGURATIONS) {
+      const configService = this.context.services.get(
+        CONFIGURATION_SERVICE
+      );
+      configService == null ? void 0 : configService.initializeDefaults([item.data]);
+    }
+    if (pointId === ContributionPointIds.COMMANDS && item.data.handler) {
+      const commandService = this.context.services.get(COMMAND_SERVICE);
+      return commandService.registerCommand(item.id, item.data.handler);
+    }
+    if (pointId === ContributionPointIds.TOOLS) {
+      const toolRegistry = this.context.services.get(
+        TOOL_REGISTRY_SERVICE
+      );
+      if (!toolRegistry) return;
+      return toolRegistry.registerTool(item.data);
+    }
+  }
+  unregister(name) {
+    const extension = this.extensionRegistry.get(name);
+    if (!extension) {
+      console.warn(`Plugin "${name}" not found.`);
+      return;
+    }
+    try {
+      extension.deactivate(this.context);
+    } catch (error) {
+      console.error(`Error in deactivate for plugin "${name}":`, error);
+    }
+    const disposables = this.extensionDisposables.get(name);
+    if (disposables) {
+      disposables.forEach((d) => d.dispose());
+      this.extensionDisposables.delete(name);
+    }
+    this.extensionRegistry.delete(name);
+    console.log(`Plugin "${name}" unregistered`);
+    return true;
+  }
+  enable(name) {
+    const extension = this.extensionRegistry.get(name);
+    if (!extension) {
+      console.warn(`Plugin "${name}" not found.`);
+      return;
+    }
+  }
+  disable(name) {
+    const extension = this.extensionRegistry.get(name);
+    if (!extension) {
+      console.warn(`Plugin "${name}" not found.`);
+      return;
+    }
+  }
+  update() {
+  }
+  destroy() {
+    const extensionNames = Array.from(this.extensionRegistry.keys());
+    extensionNames.forEach((name) => this.unregister(name));
   }
 };
 
@@ -476,19 +907,37 @@ var Pooder = class {
   constructor() {
     this.eventBus = new event_default();
     this.services = new ServiceRegistry();
+    this.serviceContext = {
+      eventBus: this.eventBus,
+      get: (identifier) => this.services.get(identifier),
+      getOrThrow: (identifier, errorMessage) => this.services.getOrThrow(identifier, errorMessage),
+      has: (identifier) => this.services.has(identifier)
+    };
     this.contributions = new ContributionRegistry();
     this.initDefaultContributionPoints();
     const commandService = new CommandService();
-    this.registerService(commandService, "CommandService");
+    this.registerService(commandService, CORE_SERVICE_TOKENS.COMMAND);
     const configurationService = new ConfigurationService();
-    this.registerService(configurationService, "ConfigurationService");
-    const workbenchService = new WorkbenchService();
-    workbenchService.setEventBus(this.eventBus);
-    this.registerService(workbenchService, "WorkbenchService");
+    this.registerService(configurationService, CORE_SERVICE_TOKENS.CONFIGURATION);
+    const toolRegistryService = new ToolRegistryService();
+    this.registerService(toolRegistryService, CORE_SERVICE_TOKENS.TOOL_REGISTRY);
+    const toolSessionService = new ToolSessionService({
+      commandService,
+      toolRegistry: toolRegistryService
+    });
+    this.registerService(toolSessionService, CORE_SERVICE_TOKENS.TOOL_SESSION);
+    const workbenchService = new WorkbenchService({
+      eventBus: this.eventBus,
+      toolRegistry: toolRegistryService,
+      sessionService: toolSessionService
+    });
+    this.registerService(workbenchService, CORE_SERVICE_TOKENS.WORKBENCH);
     const context = {
       eventBus: this.eventBus,
       services: {
-        get: (serviceName) => this.services.get(serviceName)
+        get: (identifier) => this.services.get(identifier),
+        getOrThrow: (identifier, errorMessage) => this.services.getOrThrow(identifier, errorMessage),
+        has: (identifier) => this.services.has(identifier)
       },
       contributions: {
         get: (pointId) => this.getContributions(pointId),
@@ -520,38 +969,102 @@ var Pooder = class {
     });
   }
   // --- Service Management ---
-  registerService(service, id) {
-    var _a;
-    const serviceId = id || service.constructor.name;
+  registerService(service, identifier, options = {}) {
+    const serviceIdentifier = this.resolveServiceIdentifier(service, identifier);
+    const serviceId = this.getServiceLabel(serviceIdentifier);
     try {
-      (_a = service == null ? void 0 : service.init) == null ? void 0 : _a.call(service);
-    } catch (e) {
-      console.error(`Error initializing service ${serviceId}:`, e);
+      const initResult = this.invokeServiceHook(service, "init");
+      if (this.isPromiseLike(initResult)) {
+        throw new Error(
+          `Service "${serviceId}" init() is async. Use registerServiceAsync() instead.`
+        );
+      }
+      this.services.register(serviceIdentifier, service, options);
+      this.eventBus.emit("service:register", service, { id: serviceId });
+      return true;
+    } catch (error) {
+      console.error(`Error initializing service ${serviceId}:`, error);
+      return false;
+    }
+  }
+  async registerServiceAsync(service, identifier, options = {}) {
+    const serviceIdentifier = this.resolveServiceIdentifier(service, identifier);
+    const serviceId = this.getServiceLabel(serviceIdentifier);
+    try {
+      await this.invokeServiceHookAsync(service, "init");
+      this.services.register(serviceIdentifier, service, options);
+      this.eventBus.emit("service:register", service, { id: serviceId });
+      return true;
+    } catch (error) {
+      console.error(`Error initializing service ${serviceId}:`, error);
       return false;
     }
-    this.services.register(serviceId, service);
-    this.eventBus.emit("service:register", service);
+  }
+  unregisterService(serviceOrIdentifier, id) {
+    const resolvedIdentifier = this.resolveUnregisterIdentifier(
+      serviceOrIdentifier,
+      id
+    );
+    const serviceId = this.getServiceLabel(resolvedIdentifier);
+    const registeredService = this.services.get(resolvedIdentifier);
+    if (!registeredService) {
+      console.warn(`Service ${serviceId} is not registered.`);
+      return true;
+    }
+    try {
+      const disposeResult = this.invokeServiceHook(registeredService, "dispose");
+      if (this.isPromiseLike(disposeResult)) {
+        throw new Error(
+          `Service "${serviceId}" dispose() is async. Use unregisterServiceAsync() instead.`
+        );
+      }
+    } catch (error) {
+      console.error(`Error disposing service ${serviceId}:`, error);
+      return false;
+    }
+    this.services.delete(resolvedIdentifier);
+    this.eventBus.emit("service:unregister", registeredService, { id: serviceId });
     return true;
   }
-  unregisterService(service, id) {
-    var _a;
-    const serviceId = id || service.constructor.name;
-    if (!this.services.has(serviceId)) {
+  async unregisterServiceAsync(serviceOrIdentifier, id) {
+    const resolvedIdentifier = this.resolveUnregisterIdentifier(
+      serviceOrIdentifier,
+      id
+    );
+    const serviceId = this.getServiceLabel(resolvedIdentifier);
+    const registeredService = this.services.get(resolvedIdentifier);
+    if (!registeredService) {
       console.warn(`Service ${serviceId} is not registered.`);
       return true;
     }
     try {
-      (_a = service == null ? void 0 : service.dispose) == null ? void 0 : _a.call(service);
-    } catch (e) {
-      console.error(`Error disposing service ${serviceId}:`, e);
+      await this.invokeServiceHookAsync(registeredService, "dispose");
+    } catch (error) {
+      console.error(`Error disposing service ${serviceId}:`, error);
       return false;
     }
-    this.services.delete(serviceId);
-    this.eventBus.emit("service:unregister", service);
+    this.services.delete(resolvedIdentifier);
+    this.eventBus.emit("service:unregister", registeredService, { id: serviceId });
     return true;
   }
-  getService(id) {
-    return this.services.get(id);
+  getService(identifier) {
+    return this.services.get(identifier);
+  }
+  getServiceOrThrow(identifier, errorMessage) {
+    return this.services.getOrThrow(identifier, errorMessage);
+  }
+  hasService(identifier) {
+    return this.services.has(identifier);
+  }
+  async dispose() {
+    var _a;
+    this.extensionManager.destroy();
+    const registrations = this.services.list().slice().reverse();
+    for (const item of registrations) {
+      const identifier = (_a = item.token) != null ? _a : item.id;
+      await this.unregisterServiceAsync(identifier);
+    }
+    this.services.clear();
   }
   // --- Contribution Management ---
   registerContributionPoint(point) {
@@ -566,8 +1079,39 @@ var Pooder = class {
   getContributions(pointId) {
     return this.contributions.get(pointId);
   }
+  resolveServiceIdentifier(service, identifier) {
+    return identifier != null ? identifier : service.constructor.name;
+  }
+  resolveUnregisterIdentifier(serviceOrIdentifier, id) {
+    if (typeof serviceOrIdentifier === "string" || isServiceToken(serviceOrIdentifier)) {
+      return serviceOrIdentifier;
+    }
+    return id != null ? id : serviceOrIdentifier.constructor.name;
+  }
+  getServiceLabel(identifier) {
+    if (typeof identifier === "string") {
+      return identifier;
+    }
+    return identifier.name;
+  }
+  invokeServiceHook(service, hook) {
+    const handler = service[hook];
+    if (!handler) {
+      return;
+    }
+    return handler.call(service, this.serviceContext);
+  }
+  async invokeServiceHookAsync(service, hook) {
+    await this.invokeServiceHook(service, hook);
+  }
+  isPromiseLike(value) {
+    return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+  }
 };
 export {
+  COMMAND_SERVICE,
+  CONFIGURATION_SERVICE,
+  CORE_SERVICE_TOKENS,
   CommandService,
   ConfigurationService,
   ContributionPointIds,
@@ -577,5 +1121,12 @@ export {
   ExtensionRegistry,
   Pooder,
   ServiceRegistry,
-  WorkbenchService
+  TOOL_REGISTRY_SERVICE,
+  TOOL_SESSION_SERVICE,
+  ToolRegistryService,
+  ToolSessionService,
+  WORKBENCH_SERVICE,
+  WorkbenchService,
+  createServiceToken,
+  isServiceToken
 };