@lcas58/esmi-api-types 1.0.22 → 1.0.24

package/dist/src/routes/events/events.handlers.d.ts

@@ -1,7 +1,9 @@
 import type { AppRouteHandler } from "../../lib/types.js";
-import type { DiscoverExternalRoute, DiscoverRoute, GetOneRoute, ListRoute, SaveExternalRoute } from "./events.routes.js";
+import type { ChatRoute, DiscoverExternalRoute, DiscoverRoute, GetOneRoute, ListRoute, SaveExternalRoute } from "./events.routes.js";
 export declare const list: AppRouteHandler<ListRoute>;
 export declare const getOne: AppRouteHandler<GetOneRoute>;
 export declare const discover: AppRouteHandler<DiscoverRoute>;
 export declare const discoverExternal: AppRouteHandler<DiscoverExternalRoute>;
 export declare const saveExternal: AppRouteHandler<SaveExternalRoute>;
+export declare const chat: AppRouteHandler<ChatRoute>;
+export declare const chatStream: (c: Parameters<AppRouteHandler<ChatRoute>>[0]) => Promise<Response>;

package/dist/src/routes/events/events.handlers.js

@@ -1,10 +1,13 @@
 import { and, eq, gte, ilike, inArray, isNotNull, lte } from "drizzle-orm";
+import { streamSSE } from "hono/streaming";
 import * as HttpStatusCodes from "stoker/http-status-codes";
 import * as HttpStatusPhrases from "stoker/http-status-phrases";
-import { agentEventsToRaw, runExternalDiscoveryAgent } from "../../agent/runner.js";
-import { saveEvents, searchLocalEvents } from "../../agent/tools.js";
+import { agentEventsToRaw, runChatAgent, runExternalDiscoveryAgent, runStreamingChatAgent } from "../../agent/runner.js";
+import { getKnownExternalUrls, saveEvents, searchLocalEvents } from "../../agent/tools.js";
 import { createDb } from "../../db/index.js";
 import { event, location } from "../../db/schema/index.js";
+import { buildCacheKey, buildSeenKey, getCachedDiscovery, markUrlsSeen, setCachedDiscovery } from "../../lib/discovery-cache.js";
+import { chatRequestSchema } from "./events.routes.js";
 export const list = async (c) => {
     const { db } = createDb(c.env);
     const query = c.req.valid("query");
@@ -15,10 +18,12 @@ export const list = async (c) => {
     const state = query.state?.trim();
     // Time window (default: now → +7 days)
     const now = new Date();
-    const from = query.from ? new Date(query.from) : now;
-    const to = query.to
-        ? new Date(query.to)
-        : new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+    const from = query.from ?? now;
+    const to = query.to ?? new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+    // If `to` was date-only (midnight), extend to end of that day
+    if (query.to && to.getUTCHours() === 0 && to.getUTCMinutes() === 0 && to.getUTCSeconds() === 0) {
+        to.setUTCHours(23, 59, 59, 999);
+    }
     const whereConditions = [];
     if (sportId) {
         whereConditions.push(eq(event.sportId, sportId));
@@ -107,17 +112,59 @@ export const discover = async (c) => {
     });
     return c.json(events, HttpStatusCodes.OK);
 };
+function filterByDateRange(events, from, to) {
+    if (!from && !to)
+        return events;
+    return events.filter((e) => {
+        const date = e.startsAt.split("T")[0];
+        if (from && date < from.split("T")[0])
+            return false;
+        if (to && date > to.split("T")[0])
+            return false;
+        return true;
+    });
+}
 export const discoverExternal = async (c) => {
     const body = c.req.valid("json");
     const { db } = createDb(c.env);
-    const previews = await runExternalDiscoveryAgent(c.env, db, {
+    const kv = c.env.DISCOVERY_CACHE;
+    const today = new Date().toISOString().split("T")[0];
+    const cacheKey = buildCacheKey(body.sportId, body.city, body.state, today);
+    const seenKey = buildSeenKey(body.sportId, body.city, body.state);
+    // Step 1: If not refresh, try cache first
+    if (!body.refresh) {
+        const cached = await getCachedDiscovery(kv, cacheKey);
+        if (cached !== null && cached.length > 0) {
+            const filtered = filterByDateRange(cached, body.from, body.to);
+            if (filtered.length > 0) {
+                console.log(`[discover] cache HIT for ${cacheKey} (${cached.length} total, ${filtered.length} in range)`);
+                return c.json(filtered, HttpStatusCodes.OK);
+            }
+            console.log(`[discover] cache HIT but 0 events in date range, falling through to agent`);
+        }
+        else {
+            console.log(`[discover] cache MISS for ${cacheKey}`);
+        }
+    }
+    // Step 2: Collect known URLs from DB for exclusion prompt
+    const dbUrls = await getKnownExternalUrls(db, body.sportId, body.city, body.state);
+    const knownUrls = dbUrls.length > 0 ? dbUrls : undefined;
+    // Step 3: Run agent web search
+    const results = await runExternalDiscoveryAgent(c.env, db, {
         sportId: body.sportId,
         city: body.city,
         state: body.state,
         from: body.from,
         to: body.to,
-    });
-    return c.json(previews, HttpStatusCodes.OK);
+    }, knownUrls);
+    // Step 4: Cache results (only if non-empty)
+    if (results.length > 0) {
+        await setCachedDiscovery(kv, cacheKey, results);
+        await markUrlsSeen(kv, seenKey, results.map((e) => e.url));
+    }
+    const filtered = filterByDateRange(results, body.from, body.to);
+    console.log(`[discover] agent returned ${results.length} events, returning ${filtered.length} in range for ${cacheKey}`);
+    return c.json(filtered, HttpStatusCodes.OK);
 };
 export const saveExternal = async (c) => {
     const { events: previews, city, state } = c.req.valid("json");
@@ -154,3 +201,45 @@ export const saveExternal = async (c) => {
     });
     return c.json(savedEvents, HttpStatusCodes.OK);
 };
+export const chat = async (c) => {
+    const body = c.req.valid("json");
+    const { db } = createDb(c.env);
+    const result = await runChatAgent(c.env, db, {
+        message: body.message,
+        history: body.history,
+        city: body.city,
+        state: body.state,
+    });
+    return c.json(result, HttpStatusCodes.OK);
+};
+export const chatStream = async (c) => {
+    const rawBody = await c.req.json();
+    const parsed = chatRequestSchema.safeParse(rawBody);
+    if (!parsed.success) {
+        return c.json({ message: "Invalid request body" }, HttpStatusCodes.UNPROCESSABLE_ENTITY);
+    }
+    const user = c.get("user");
+    if (!user) {
+        return c.json({ message: "Unauthorized" }, HttpStatusCodes.UNAUTHORIZED);
+    }
+    const { db } = createDb(c.env);
+    const body = parsed.data;
+    return streamSSE(c, async (stream) => {
+        const writer = async (event) => {
+            await stream.writeSSE({ data: JSON.stringify(event) });
+        };
+        try {
+            await runStreamingChatAgent(c.env, db, {
+                message: body.message,
+                history: body.history,
+                city: body.city,
+                state: body.state,
+            }, writer);
+        }
+        catch (err) {
+            console.error("[chatStream] error:", err);
+            await stream.writeSSE({ data: JSON.stringify({ type: "error", message: "Stream failed" }) });
+            await stream.writeSSE({ data: JSON.stringify({ type: "done" }) });
+        }
+    });
+};

package/dist/src/routes/events/events.index.d.ts

@@ -128,6 +128,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     state: string;
                     from?: string | undefined;
                     to?: string | undefined;
+                    refresh?: boolean | undefined;
                 };
             };
             output: {
@@ -179,6 +180,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     state: string;
                     from?: string | undefined;
                     to?: string | undefined;
+                    refresh?: boolean | undefined;
                 };
             };
             output: {
@@ -198,6 +200,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     state: string;
                     from?: string | undefined;
                     to?: string | undefined;
+                    refresh?: boolean | undefined;
                 };
             };
             output: {
@@ -213,6 +216,7 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
                     state: string;
                     from?: string | undefined;
                     to?: string | undefined;
+                    refresh?: boolean | undefined;
                 };
             };
             output: {
@@ -325,5 +329,57 @@ declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shar
             status: 401;
         };
     };
+} & {
+    "/events/chat": {
+        $post: {
+            input: {
+                json: {
+                    message: string;
+                    city?: string | undefined;
+                    state?: string | undefined;
+                    history?: {
+                        content: string;
+                        role: "user" | "assistant";
+                    }[] | undefined;
+                };
+            };
+            output: {
+                message: string;
+            };
+            outputFormat: "text" | "json";
+            status: 401;
+        } | {
+            input: {
+                json: {
+                    message: string;
+                    city?: string | undefined;
+                    state?: string | undefined;
+                    history?: {
+                        content: string;
+                        role: "user" | "assistant";
+                    }[] | undefined;
+                };
+            };
+            output: {
+                events: {
+                    url: string;
+                    id: string;
+                    title: string;
+                    sport: string;
+                    startsAt: string;
+                    timezone: string;
+                    formattedAddress: string;
+                    latitude: number | null;
+                    longitude: number | null;
+                    venueName: string;
+                    description?: string | undefined;
+                    endsAt?: string | undefined;
+                }[];
+                reply: string;
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
 }, "/">;
 export default router;

package/dist/src/routes/events/events.index.js

@@ -1,4 +1,5 @@
 import { createRouter } from "../../lib/create-app.js";
+import { isAuth } from "../../middlewares/is-auth.js";
 import * as handlers from "./events.handlers.js";
 import * as routes from "./events.routes.js";
 const router = createRouter()
@@ -6,5 +7,8 @@ const router = createRouter()
     .openapi(routes.getOne, handlers.getOne)
     .openapi(routes.discover, handlers.discover)
     .openapi(routes.discoverExternal, handlers.discoverExternal)
-    .openapi(routes.saveExternal, handlers.saveExternal);
+    .openapi(routes.saveExternal, handlers.saveExternal)
+    .openapi(routes.chat, handlers.chat);
+// SSE streaming route (not in OpenAPI spec — SSE responses can't be modeled in JSON schema)
+router.post("/events/chat/stream", isAuth(), handlers.chatStream);
 export default router;

package/dist/src/routes/events/events.routes.d.ts

@@ -594,10 +594,12 @@ export declare const discoverRequestSchema: z.ZodObject<{
     state: z.ZodString;
     from: z.ZodOptional<z.ZodString>;
     to: z.ZodOptional<z.ZodString>;
+    refresh: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     sportId: string;
     city: string;
     state: string;
+    refresh: boolean;
     from?: string | undefined;
     to?: string | undefined;
 }, {
@@ -606,6 +608,7 @@ export declare const discoverRequestSchema: z.ZodObject<{
     state: string;
     from?: string | undefined;
     to?: string | undefined;
+    refresh?: boolean | undefined;
 }>;
 export declare const discover: {
     path: "/events/discover";
@@ -623,10 +626,12 @@ export declare const discover: {
                         state: z.ZodString;
                         from: z.ZodOptional<z.ZodString>;
                         to: z.ZodOptional<z.ZodString>;
+                        refresh: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                     }, "strip", z.ZodTypeAny, {
                         sportId: string;
                         city: string;
                         state: string;
+                        refresh: boolean;
                         from?: string | undefined;
                         to?: string | undefined;
                     }, {
@@ -635,6 +640,7 @@ export declare const discover: {
                         state: string;
                         from?: string | undefined;
                         to?: string | undefined;
+                        refresh?: boolean | undefined;
                     }>;
                 };
             };
@@ -935,10 +941,12 @@ export declare const discoverExternal: {
                         state: z.ZodString;
                         from: z.ZodOptional<z.ZodString>;
                         to: z.ZodOptional<z.ZodString>;
+                        refresh: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                     }, "strip", z.ZodTypeAny, {
                         sportId: string;
                         city: string;
                         state: string;
+                        refresh: boolean;
                         from?: string | undefined;
                         to?: string | undefined;
                     }, {
@@ -947,6 +955,7 @@ export declare const discoverExternal: {
                         state: string;
                         from?: string | undefined;
                         to?: string | undefined;
+                        refresh?: boolean | undefined;
                     }>;
                 };
             };
@@ -1390,8 +1399,262 @@ export declare const saveExternal: {
 } & {
     getRoutingPath(): "/events/save-external";
 };
+export declare const chatRequestSchema: z.ZodObject<{
+    message: z.ZodString;
+    history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["user", "assistant"]>;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        role: "user" | "assistant";
+    }, {
+        content: string;
+        role: "user" | "assistant";
+    }>, "many">>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    city?: string | undefined;
+    state?: string | undefined;
+    history?: {
+        content: string;
+        role: "user" | "assistant";
+    }[] | undefined;
+}, {
+    message: string;
+    city?: string | undefined;
+    state?: string | undefined;
+    history?: {
+        content: string;
+        role: "user" | "assistant";
+    }[] | undefined;
+}>;
+export declare const chatResponseSchema: z.ZodObject<{
+    reply: z.ZodString;
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        sport: z.ZodString;
+        startsAt: z.ZodString;
+        timezone: z.ZodString;
+        url: z.ZodString;
+        venueName: z.ZodString;
+        formattedAddress: z.ZodString;
+        latitude: z.ZodNullable<z.ZodNumber>;
+        longitude: z.ZodNullable<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+        endsAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        id: string;
+        title: string;
+        sport: string;
+        startsAt: string;
+        timezone: string;
+        formattedAddress: string;
+        latitude: number | null;
+        longitude: number | null;
+        venueName: string;
+        description?: string | undefined;
+        endsAt?: string | undefined;
+    }, {
+        url: string;
+        id: string;
+        title: string;
+        sport: string;
+        startsAt: string;
+        timezone: string;
+        formattedAddress: string;
+        latitude: number | null;
+        longitude: number | null;
+        venueName: string;
+        description?: string | undefined;
+        endsAt?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    events: {
+        url: string;
+        id: string;
+        title: string;
+        sport: string;
+        startsAt: string;
+        timezone: string;
+        formattedAddress: string;
+        latitude: number | null;
+        longitude: number | null;
+        venueName: string;
+        description?: string | undefined;
+        endsAt?: string | undefined;
+    }[];
+    reply: string;
+}, {
+    events: {
+        url: string;
+        id: string;
+        title: string;
+        sport: string;
+        startsAt: string;
+        timezone: string;
+        formattedAddress: string;
+        latitude: number | null;
+        longitude: number | null;
+        venueName: string;
+        description?: string | undefined;
+        endsAt?: string | undefined;
+    }[];
+    reply: string;
+}>;
+export declare const chat: {
+    path: "/events/chat";
+    method: "post";
+    tags: string[];
+    middleware: [import("hono").MiddlewareHandler];
+    request: {
+        body: {
+            required: boolean;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        message: z.ZodString;
+                        history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            role: z.ZodEnum<["user", "assistant"]>;
+                            content: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            content: string;
+                            role: "user" | "assistant";
+                        }, {
+                            content: string;
+                            role: "user" | "assistant";
+                        }>, "many">>;
+                        city: z.ZodOptional<z.ZodString>;
+                        state: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                        city?: string | undefined;
+                        state?: string | undefined;
+                        history?: {
+                            content: string;
+                            role: "user" | "assistant";
+                        }[] | undefined;
+                    }, {
+                        message: string;
+                        city?: string | undefined;
+                        state?: string | undefined;
+                        history?: {
+                            content: string;
+                            role: "user" | "assistant";
+                        }[] | undefined;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        reply: z.ZodString;
+                        events: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            title: z.ZodString;
+                            sport: z.ZodString;
+                            startsAt: z.ZodString;
+                            timezone: z.ZodString;
+                            url: z.ZodString;
+                            venueName: z.ZodString;
+                            formattedAddress: z.ZodString;
+                            latitude: z.ZodNullable<z.ZodNumber>;
+                            longitude: z.ZodNullable<z.ZodNumber>;
+                            description: z.ZodOptional<z.ZodString>;
+                            endsAt: z.ZodOptional<z.ZodString>;
+                        }, "strip", z.ZodTypeAny, {
+                            url: string;
+                            id: string;
+                            title: string;
+                            sport: string;
+                            startsAt: string;
+                            timezone: string;
+                            formattedAddress: string;
+                            latitude: number | null;
+                            longitude: number | null;
+                            venueName: string;
+                            description?: string | undefined;
+                            endsAt?: string | undefined;
+                        }, {
+                            url: string;
+                            id: string;
+                            title: string;
+                            sport: string;
+                            startsAt: string;
+                            timezone: string;
+                            formattedAddress: string;
+                            latitude: number | null;
+                            longitude: number | null;
+                            venueName: string;
+                            description?: string | undefined;
+                            endsAt?: string | undefined;
+                        }>, "many">;
+                    }, "strip", z.ZodTypeAny, {
+                        events: {
+                            url: string;
+                            id: string;
+                            title: string;
+                            sport: string;
+                            startsAt: string;
+                            timezone: string;
+                            formattedAddress: string;
+                            latitude: number | null;
+                            longitude: number | null;
+                            venueName: string;
+                            description?: string | undefined;
+                            endsAt?: string | undefined;
+                        }[];
+                        reply: string;
+                    }, {
+                        events: {
+                            url: string;
+                            id: string;
+                            title: string;
+                            sport: string;
+                            startsAt: string;
+                            timezone: string;
+                            formattedAddress: string;
+                            latitude: number | null;
+                            longitude: number | null;
+                            venueName: string;
+                            description?: string | undefined;
+                            endsAt?: string | undefined;
+                        }[];
+                        reply: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+        401: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        message: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        message: string;
+                    }, {
+                        message: string;
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/events/chat";
+};
 export type ListRoute = typeof list;
 export type GetOneRoute = typeof getOne;
 export type DiscoverRoute = typeof discover;
 export type DiscoverExternalRoute = typeof discoverExternal;
 export type SaveExternalRoute = typeof saveExternal;
+export type ChatRoute = typeof chat;

package/dist/src/routes/events/events.routes.js

@@ -35,6 +35,7 @@ export const discoverRequestSchema = z.object({
     state: z.string().min(1),
     from: z.string().optional(),
     to: z.string().optional(),
+    refresh: z.boolean().optional().default(false),
 });
 export const discover = createRoute({
     path: "/events/discover",
@@ -79,3 +80,30 @@ export const saveExternal = createRoute({
         [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
     },
 });
+const chatMessageSchema = z.object({
+    role: z.enum(["user", "assistant"]),
+    content: z.string(),
+});
+export const chatRequestSchema = z.object({
+    message: z.string().min(1),
+    history: z.array(chatMessageSchema).optional(),
+    city: z.string().optional(),
+    state: z.string().optional(),
+});
+export const chatResponseSchema = z.object({
+    reply: z.string(),
+    events: z.array(externalEventPreviewSchema),
+});
+export const chat = createRoute({
+    path: "/events/chat",
+    method: "post",
+    tags: ["Events"],
+    middleware: [isAuth()],
+    request: {
+        body: jsonContentRequired(chatRequestSchema, "Chat message"),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(chatResponseSchema, "Chat response with friendly text and events"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
+    },
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lcas58/esmi-api-types",
   "type": "module",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "license": "MIT",
   "exports": {
     ".": {